os_windows.cpp revision 2562:bf6481e5f96d
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::pd_print_cpu_info(outputStream* st) { 1724 // Nothing to do for now. 1725} 1726 1727void os::print_memory_info(outputStream* st) { 1728 st->print("Memory:"); 1729 st->print(" %dk page", os::vm_page_size()>>10); 1730 1731 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect 1732 // value if total memory is larger than 4GB 1733 MEMORYSTATUSEX ms; 1734 ms.dwLength = sizeof(ms); 1735 GlobalMemoryStatusEx(&ms); 1736 1737 st->print(", physical %uk", os::physical_memory() >> 10); 1738 st->print("(%uk free)", os::available_memory() >> 10); 1739 1740 st->print(", swap %uk", ms.ullTotalPageFile >> 10); 1741 st->print("(%uk free)", ms.ullAvailPageFile >> 10); 1742 st->cr(); 1743} 1744 1745void os::print_siginfo(outputStream *st, void *siginfo) { 1746 EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo; 1747 st->print("siginfo:"); 1748 st->print(" ExceptionCode=0x%x", er->ExceptionCode); 1749 1750 if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 1751 er->NumberParameters >= 2) { 1752 switch (er->ExceptionInformation[0]) { 1753 case 0: st->print(", reading address"); break; 1754 case 1: st->print(", writing address"); break; 1755 default: st->print(", ExceptionInformation=" INTPTR_FORMAT, 1756 er->ExceptionInformation[0]); 1757 } 1758 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]); 1759 } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR && 1760 er->NumberParameters >= 2 && UseSharedSpaces) { 1761 FileMapInfo* mapinfo = FileMapInfo::current_info(); 1762 if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) { 1763 st->print("\n\nError accessing class data sharing archive." \ 1764 " Mapped file inaccessible during execution, " \ 1765 " possible disk/network problem."); 1766 } 1767 } else { 1768 int num = er->NumberParameters; 1769 if (num > 0) { 1770 st->print(", ExceptionInformation="); 1771 for (int i = 0; i < num; i++) { 1772 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]); 1773 } 1774 } 1775 } 1776 st->cr(); 1777} 1778 1779void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) { 1780 // do nothing 1781} 1782 1783static char saved_jvm_path[MAX_PATH] = {0}; 1784 1785// Find the full path to the current module, jvm.dll or jvm_g.dll 1786void os::jvm_path(char *buf, jint buflen) { 1787 // Error checking. 1788 if (buflen < MAX_PATH) { 1789 assert(false, "must use a large-enough buffer"); 1790 buf[0] = '\0'; 1791 return; 1792 } 1793 // Lazy resolve the path to current module. 1794 if (saved_jvm_path[0] != 0) { 1795 strcpy(buf, saved_jvm_path); 1796 return; 1797 } 1798 1799 buf[0] = '\0'; 1800 if (Arguments::created_by_gamma_launcher()) { 1801 // Support for the gamma launcher. Check for an 1802 // JAVA_HOME environment variable 1803 // and fix up the path so it looks like 1804 // libjvm.so is installed there (append a fake suffix 1805 // hotspot/libjvm.so). 1806 char* java_home_var = ::getenv("JAVA_HOME"); 1807 if (java_home_var != NULL && java_home_var[0] != 0) { 1808 1809 strncpy(buf, java_home_var, buflen); 1810 1811 // determine if this is a legacy image or modules image 1812 // modules image doesn't have "jre" subdirectory 1813 size_t len = strlen(buf); 1814 char* jrebin_p = buf + len; 1815 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\"); 1816 if (0 != _access(buf, 0)) { 1817 jio_snprintf(jrebin_p, buflen-len, "\\bin\\"); 1818 } 1819 len = strlen(buf); 1820 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll"); 1821 } 1822 } 1823 1824 if(buf[0] == '\0') { 1825 GetModuleFileName(vm_lib_handle, buf, buflen); 1826 } 1827 strcpy(saved_jvm_path, buf); 1828} 1829 1830 1831void os::print_jni_name_prefix_on(outputStream* st, int args_size) { 1832#ifndef _WIN64 1833 st->print("_"); 1834#endif 1835} 1836 1837 1838void os::print_jni_name_suffix_on(outputStream* st, int args_size) { 1839#ifndef _WIN64 1840 st->print("@%d", args_size * sizeof(int)); 1841#endif 1842} 1843 1844// This method is a copy of JDK's sysGetLastErrorString 1845// from src/windows/hpi/src/system_md.c 1846 1847size_t os::lasterror(char *buf, size_t len) { 1848 long errval; 1849 1850 if ((errval = GetLastError()) != 0) { 1851 /* DOS error */ 1852 int n = (int)FormatMessage( 1853 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 1854 NULL, 1855 errval, 1856 0, 1857 buf, 1858 (DWORD)len, 1859 NULL); 1860 if (n > 3) { 1861 /* Drop final '.', CR, LF */ 1862 if (buf[n - 1] == '\n') n--; 1863 if (buf[n - 1] == '\r') n--; 1864 if (buf[n - 1] == '.') n--; 1865 buf[n] = '\0'; 1866 } 1867 return n; 1868 } 1869 1870 if (errno != 0) { 1871 /* C runtime error that has no corresponding DOS error code */ 1872 const char *s = strerror(errno); 1873 size_t n = strlen(s); 1874 if (n >= len) n = len - 1; 1875 strncpy(buf, s, n); 1876 buf[n] = '\0'; 1877 return n; 1878 } 1879 return 0; 1880} 1881 1882// sun.misc.Signal 1883// NOTE that this is a workaround for an apparent kernel bug where if 1884// a signal handler for SIGBREAK is installed then that signal handler 1885// takes priority over the console control handler for CTRL_CLOSE_EVENT. 1886// See bug 4416763. 1887static void (*sigbreakHandler)(int) = NULL; 1888 1889static void UserHandler(int sig, void *siginfo, void *context) { 1890 os::signal_notify(sig); 1891 // We need to reinstate the signal handler each time... 1892 os::signal(sig, (void*)UserHandler); 1893} 1894 1895void* os::user_handler() { 1896 return (void*) UserHandler; 1897} 1898 1899void* os::signal(int signal_number, void* handler) { 1900 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) { 1901 void (*oldHandler)(int) = sigbreakHandler; 1902 sigbreakHandler = (void (*)(int)) handler; 1903 return (void*) oldHandler; 1904 } else { 1905 return (void*)::signal(signal_number, (void (*)(int))handler); 1906 } 1907} 1908 1909void os::signal_raise(int signal_number) { 1910 raise(signal_number); 1911} 1912 1913// The Win32 C runtime library maps all console control events other than ^C 1914// into SIGBREAK, which makes it impossible to distinguish ^BREAK from close, 1915// logoff, and shutdown events. We therefore install our own console handler 1916// that raises SIGTERM for the latter cases. 1917// 1918static BOOL WINAPI consoleHandler(DWORD event) { 1919 switch(event) { 1920 case CTRL_C_EVENT: 1921 if (is_error_reported()) { 1922 // Ctrl-C is pressed during error reporting, likely because the error 1923 // handler fails to abort. Let VM die immediately. 1924 os::die(); 1925 } 1926 1927 os::signal_raise(SIGINT); 1928 return TRUE; 1929 break; 1930 case CTRL_BREAK_EVENT: 1931 if (sigbreakHandler != NULL) { 1932 (*sigbreakHandler)(SIGBREAK); 1933 } 1934 return TRUE; 1935 break; 1936 case CTRL_CLOSE_EVENT: 1937 case CTRL_LOGOFF_EVENT: 1938 case CTRL_SHUTDOWN_EVENT: 1939 os::signal_raise(SIGTERM); 1940 return TRUE; 1941 break; 1942 default: 1943 break; 1944 } 1945 return FALSE; 1946} 1947 1948/* 1949 * The following code is moved from os.cpp for making this 1950 * code platform specific, which it is by its very nature. 1951 */ 1952 1953// Return maximum OS signal used + 1 for internal use only 1954// Used as exit signal for signal_thread 1955int os::sigexitnum_pd(){ 1956 return NSIG; 1957} 1958 1959// a counter for each possible signal value, including signal_thread exit signal 1960static volatile jint pending_signals[NSIG+1] = { 0 }; 1961static HANDLE sig_sem; 1962 1963void os::signal_init_pd() { 1964 // Initialize signal structures 1965 memset((void*)pending_signals, 0, sizeof(pending_signals)); 1966 1967 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL); 1968 1969 // Programs embedding the VM do not want it to attempt to receive 1970 // events like CTRL_LOGOFF_EVENT, which are used to implement the 1971 // shutdown hooks mechanism introduced in 1.3. For example, when 1972 // the VM is run as part of a Windows NT service (i.e., a servlet 1973 // engine in a web server), the correct behavior is for any console 1974 // control handler to return FALSE, not TRUE, because the OS's 1975 // "final" handler for such events allows the process to continue if 1976 // it is a service (while terminating it if it is not a service). 1977 // To make this behavior uniform and the mechanism simpler, we 1978 // completely disable the VM's usage of these console events if -Xrs 1979 // (=ReduceSignalUsage) is specified. This means, for example, that 1980 // the CTRL-BREAK thread dump mechanism is also disabled in this 1981 // case. See bugs 4323062, 4345157, and related bugs. 1982 1983 if (!ReduceSignalUsage) { 1984 // Add a CTRL-C handler 1985 SetConsoleCtrlHandler(consoleHandler, TRUE); 1986 } 1987} 1988 1989void os::signal_notify(int signal_number) { 1990 BOOL ret; 1991 1992 Atomic::inc(&pending_signals[signal_number]); 1993 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 1994 assert(ret != 0, "ReleaseSemaphore() failed"); 1995} 1996 1997static int check_pending_signals(bool wait_for_signal) { 1998 DWORD ret; 1999 while (true) { 2000 for (int i = 0; i < NSIG + 1; i++) { 2001 jint n = pending_signals[i]; 2002 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) { 2003 return i; 2004 } 2005 } 2006 if (!wait_for_signal) { 2007 return -1; 2008 } 2009 2010 JavaThread *thread = JavaThread::current(); 2011 2012 ThreadBlockInVM tbivm(thread); 2013 2014 bool threadIsSuspended; 2015 do { 2016 thread->set_suspend_equivalent(); 2017 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self() 2018 ret = ::WaitForSingleObject(sig_sem, INFINITE); 2019 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed"); 2020 2021 // were we externally suspended while we were waiting? 2022 threadIsSuspended = thread->handle_special_suspend_equivalent_condition(); 2023 if (threadIsSuspended) { 2024 // 2025 // The semaphore has been incremented, but while we were waiting 2026 // another thread suspended us. We don't want to continue running 2027 // while suspended because that would surprise the thread that 2028 // suspended us. 2029 // 2030 ret = ::ReleaseSemaphore(sig_sem, 1, NULL); 2031 assert(ret != 0, "ReleaseSemaphore() failed"); 2032 2033 thread->java_suspend_self(); 2034 } 2035 } while (threadIsSuspended); 2036 } 2037} 2038 2039int os::signal_lookup() { 2040 return check_pending_signals(false); 2041} 2042 2043int os::signal_wait() { 2044 return check_pending_signals(true); 2045} 2046 2047// Implicit OS exception handling 2048 2049LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) { 2050 JavaThread* thread = JavaThread::current(); 2051 // Save pc in thread 2052#ifdef _M_IA64 2053 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP); 2054 // Set pc to handler 2055 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler; 2056#elif _M_AMD64 2057 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip); 2058 // Set pc to handler 2059 exceptionInfo->ContextRecord->Rip = (DWORD64)handler; 2060#else 2061 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip); 2062 // Set pc to handler 2063 exceptionInfo->ContextRecord->Eip = (LONG)handler; 2064#endif 2065 2066 // Continue the execution 2067 return EXCEPTION_CONTINUE_EXECUTION; 2068} 2069 2070 2071// Used for PostMortemDump 2072extern "C" void safepoints(); 2073extern "C" void find(int x); 2074extern "C" void events(); 2075 2076// According to Windows API documentation, an illegal instruction sequence should generate 2077// the 0xC000001C exception code. However, real world experience shows that occasionnaly 2078// the execution of an illegal instruction can generate the exception code 0xC000001E. This 2079// seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems). 2080 2081#define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E 2082 2083// From "Execution Protection in the Windows Operating System" draft 0.35 2084// Once a system header becomes available, the "real" define should be 2085// included or copied here. 2086#define EXCEPTION_INFO_EXEC_VIOLATION 0x08 2087 2088#define def_excpt(val) #val, val 2089 2090struct siglabel { 2091 char *name; 2092 int number; 2093}; 2094 2095// All Visual C++ exceptions thrown from code generated by the Microsoft Visual 2096// C++ compiler contain this error code. Because this is a compiler-generated 2097// error, the code is not listed in the Win32 API header files. 2098// The code is actually a cryptic mnemonic device, with the initial "E" 2099// standing for "exception" and the final 3 bytes (0x6D7363) representing the 2100// ASCII values of "msc". 2101 2102#define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363 2103 2104 2105struct siglabel exceptlabels[] = { 2106 def_excpt(EXCEPTION_ACCESS_VIOLATION), 2107 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT), 2108 def_excpt(EXCEPTION_BREAKPOINT), 2109 def_excpt(EXCEPTION_SINGLE_STEP), 2110 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED), 2111 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND), 2112 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO), 2113 def_excpt(EXCEPTION_FLT_INEXACT_RESULT), 2114 def_excpt(EXCEPTION_FLT_INVALID_OPERATION), 2115 def_excpt(EXCEPTION_FLT_OVERFLOW), 2116 def_excpt(EXCEPTION_FLT_STACK_CHECK), 2117 def_excpt(EXCEPTION_FLT_UNDERFLOW), 2118 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO), 2119 def_excpt(EXCEPTION_INT_OVERFLOW), 2120 def_excpt(EXCEPTION_PRIV_INSTRUCTION), 2121 def_excpt(EXCEPTION_IN_PAGE_ERROR), 2122 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION), 2123 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2), 2124 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION), 2125 def_excpt(EXCEPTION_STACK_OVERFLOW), 2126 def_excpt(EXCEPTION_INVALID_DISPOSITION), 2127 def_excpt(EXCEPTION_GUARD_PAGE), 2128 def_excpt(EXCEPTION_INVALID_HANDLE), 2129 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION), 2130 NULL, 0 2131}; 2132 2133const char* os::exception_name(int exception_code, char *buf, size_t size) { 2134 for (int i = 0; exceptlabels[i].name != NULL; i++) { 2135 if (exceptlabels[i].number == exception_code) { 2136 jio_snprintf(buf, size, "%s", exceptlabels[i].name); 2137 return buf; 2138 } 2139 } 2140 2141 return NULL; 2142} 2143 2144//----------------------------------------------------------------------------- 2145LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 2146 // handle exception caused by idiv; should only happen for -MinInt/-1 2147 // (division by zero is handled explicitly) 2148#ifdef _M_IA64 2149 assert(0, "Fix Handle_IDiv_Exception"); 2150#elif _M_AMD64 2151 PCONTEXT ctx = exceptionInfo->ContextRecord; 2152 address pc = (address)ctx->Rip; 2153 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc)); 2154 assert(pc[0] == 0xF7, "not an idiv opcode"); 2155 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2156 assert(ctx->Rax == min_jint, "unexpected idiv exception"); 2157 // set correct result values and continue after idiv instruction 2158 ctx->Rip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes 2159 ctx->Rax = (DWORD)min_jint; // result 2160 ctx->Rdx = (DWORD)0; // remainder 2161 // Continue the execution 2162#else 2163 PCONTEXT ctx = exceptionInfo->ContextRecord; 2164 address pc = (address)ctx->Eip; 2165 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc)); 2166 assert(pc[0] == 0xF7, "not an idiv opcode"); 2167 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands"); 2168 assert(ctx->Eax == min_jint, "unexpected idiv exception"); 2169 // set correct result values and continue after idiv instruction 2170 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes 2171 ctx->Eax = (DWORD)min_jint; // result 2172 ctx->Edx = (DWORD)0; // remainder 2173 // Continue the execution 2174#endif 2175 return EXCEPTION_CONTINUE_EXECUTION; 2176} 2177 2178#ifndef _WIN64 2179//----------------------------------------------------------------------------- 2180LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) { 2181 // handle exception caused by native method modifying control word 2182 PCONTEXT ctx = exceptionInfo->ContextRecord; 2183 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2184 2185 switch (exception_code) { 2186 case EXCEPTION_FLT_DENORMAL_OPERAND: 2187 case EXCEPTION_FLT_DIVIDE_BY_ZERO: 2188 case EXCEPTION_FLT_INEXACT_RESULT: 2189 case EXCEPTION_FLT_INVALID_OPERATION: 2190 case EXCEPTION_FLT_OVERFLOW: 2191 case EXCEPTION_FLT_STACK_CHECK: 2192 case EXCEPTION_FLT_UNDERFLOW: 2193 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std()); 2194 if (fp_control_word != ctx->FloatSave.ControlWord) { 2195 // Restore FPCW and mask out FLT exceptions 2196 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0; 2197 // Mask out pending FLT exceptions 2198 ctx->FloatSave.StatusWord &= 0xffffff00; 2199 return EXCEPTION_CONTINUE_EXECUTION; 2200 } 2201 } 2202 2203 if (prev_uef_handler != NULL) { 2204 // We didn't handle this exception so pass it to the previous 2205 // UnhandledExceptionFilter. 2206 return (prev_uef_handler)(exceptionInfo); 2207 } 2208 2209 return EXCEPTION_CONTINUE_SEARCH; 2210} 2211#else //_WIN64 2212/* 2213 On Windows, the mxcsr control bits are non-volatile across calls 2214 See also CR 6192333 2215 If EXCEPTION_FLT_* happened after some native method modified 2216 mxcsr - it is not a jvm fault. 2217 However should we decide to restore of mxcsr after a faulty 2218 native method we can uncomment following code 2219 jint MxCsr = INITIAL_MXCSR; 2220 // we can't use StubRoutines::addr_mxcsr_std() 2221 // because in Win64 mxcsr is not saved there 2222 if (MxCsr != ctx->MxCsr) { 2223 ctx->MxCsr = MxCsr; 2224 return EXCEPTION_CONTINUE_EXECUTION; 2225 } 2226 2227*/ 2228#endif //_WIN64 2229 2230 2231// Fatal error reporting is single threaded so we can make this a 2232// static and preallocated. If it's more than MAX_PATH silently ignore 2233// it. 2234static char saved_error_file[MAX_PATH] = {0}; 2235 2236void os::set_error_file(const char *logfile) { 2237 if (strlen(logfile) <= MAX_PATH) { 2238 strncpy(saved_error_file, logfile, MAX_PATH); 2239 } 2240} 2241 2242static inline void report_error(Thread* t, DWORD exception_code, 2243 address addr, void* siginfo, void* context) { 2244 VMError err(t, exception_code, addr, siginfo, context); 2245 err.report_and_die(); 2246 2247 // If UseOsErrorReporting, this will return here and save the error file 2248 // somewhere where we can find it in the minidump. 2249} 2250 2251//----------------------------------------------------------------------------- 2252LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2253 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH; 2254 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2255#ifdef _M_IA64 2256 address pc = (address) exceptionInfo->ContextRecord->StIIP; 2257#elif _M_AMD64 2258 address pc = (address) exceptionInfo->ContextRecord->Rip; 2259#else 2260 address pc = (address) exceptionInfo->ContextRecord->Eip; 2261#endif 2262 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady 2263 2264#ifndef _WIN64 2265 // Execution protection violation - win32 running on AMD64 only 2266 // Handled first to avoid misdiagnosis as a "normal" access violation; 2267 // This is safe to do because we have a new/unique ExceptionInformation 2268 // code for this condition. 2269 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2270 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2271 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0]; 2272 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2273 2274 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) { 2275 int page_size = os::vm_page_size(); 2276 2277 // Make sure the pc and the faulting address are sane. 2278 // 2279 // If an instruction spans a page boundary, and the page containing 2280 // the beginning of the instruction is executable but the following 2281 // page is not, the pc and the faulting address might be slightly 2282 // different - we still want to unguard the 2nd page in this case. 2283 // 2284 // 15 bytes seems to be a (very) safe value for max instruction size. 2285 bool pc_is_near_addr = 2286 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15); 2287 bool instr_spans_page_boundary = 2288 (align_size_down((intptr_t) pc ^ (intptr_t) addr, 2289 (intptr_t) page_size) > 0); 2290 2291 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) { 2292 static volatile address last_addr = 2293 (address) os::non_memory_address_word(); 2294 2295 // In conservative mode, don't unguard unless the address is in the VM 2296 if (UnguardOnExecutionViolation > 0 && addr != last_addr && 2297 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) { 2298 2299 // Set memory to RWX and retry 2300 address page_start = 2301 (address) align_size_down((intptr_t) addr, (intptr_t) page_size); 2302 bool res = os::protect_memory((char*) page_start, page_size, 2303 os::MEM_PROT_RWX); 2304 2305 if (PrintMiscellaneous && Verbose) { 2306 char buf[256]; 2307 jio_snprintf(buf, sizeof(buf), "Execution protection violation " 2308 "at " INTPTR_FORMAT 2309 ", unguarding " INTPTR_FORMAT ": %s", addr, 2310 page_start, (res ? "success" : strerror(errno))); 2311 tty->print_raw_cr(buf); 2312 } 2313 2314 // Set last_addr so if we fault again at the same address, we don't 2315 // end up in an endless loop. 2316 // 2317 // There are two potential complications here. Two threads trapping 2318 // at the same address at the same time could cause one of the 2319 // threads to think it already unguarded, and abort the VM. Likely 2320 // very rare. 2321 // 2322 // The other race involves two threads alternately trapping at 2323 // different addresses and failing to unguard the page, resulting in 2324 // an endless loop. This condition is probably even more unlikely 2325 // than the first. 2326 // 2327 // Although both cases could be avoided by using locks or thread 2328 // local last_addr, these solutions are unnecessary complication: 2329 // this handler is a best-effort safety net, not a complete solution. 2330 // It is disabled by default and should only be used as a workaround 2331 // in case we missed any no-execute-unsafe VM code. 2332 2333 last_addr = addr; 2334 2335 return EXCEPTION_CONTINUE_EXECUTION; 2336 } 2337 } 2338 2339 // Last unguard failed or not unguarding 2340 tty->print_raw_cr("Execution protection violation"); 2341 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord, 2342 exceptionInfo->ContextRecord); 2343 return EXCEPTION_CONTINUE_SEARCH; 2344 } 2345 } 2346#endif // _WIN64 2347 2348 // Check to see if we caught the safepoint code in the 2349 // process of write protecting the memory serialization page. 2350 // It write enables the page immediately after protecting it 2351 // so just return. 2352 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) { 2353 JavaThread* thread = (JavaThread*) t; 2354 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2355 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2356 if ( os::is_memory_serialize_page(thread, addr) ) { 2357 // Block current thread until the memory serialize page permission restored. 2358 os::block_on_serialize_page_trap(); 2359 return EXCEPTION_CONTINUE_EXECUTION; 2360 } 2361 } 2362 2363 if (t != NULL && t->is_Java_thread()) { 2364 JavaThread* thread = (JavaThread*) t; 2365 bool in_java = thread->thread_state() == _thread_in_Java; 2366 2367 // Handle potential stack overflows up front. 2368 if (exception_code == EXCEPTION_STACK_OVERFLOW) { 2369 if (os::uses_stack_guard_pages()) { 2370#ifdef _M_IA64 2371 // 2372 // If it's a legal stack address continue, Windows will map it in. 2373 // 2374 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2375 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2376 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) 2377 return EXCEPTION_CONTINUE_EXECUTION; 2378 2379 // The register save area is the same size as the memory stack 2380 // and starts at the page just above the start of the memory stack. 2381 // If we get a fault in this area, we've run out of register 2382 // stack. If we are in java, try throwing a stack overflow exception. 2383 if (addr > thread->stack_base() && 2384 addr <= (thread->stack_base()+thread->stack_size()) ) { 2385 char buf[256]; 2386 jio_snprintf(buf, sizeof(buf), 2387 "Register stack overflow, addr:%p, stack_base:%p\n", 2388 addr, thread->stack_base() ); 2389 tty->print_raw_cr(buf); 2390 // If not in java code, return and hope for the best. 2391 return in_java ? Handle_Exception(exceptionInfo, 2392 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)) 2393 : EXCEPTION_CONTINUE_EXECUTION; 2394 } 2395#endif 2396 if (thread->stack_yellow_zone_enabled()) { 2397 // Yellow zone violation. The o/s has unprotected the first yellow 2398 // zone page for us. Note: must call disable_stack_yellow_zone to 2399 // update the enabled status, even if the zone contains only one page. 2400 thread->disable_stack_yellow_zone(); 2401 // If not in java code, return and hope for the best. 2402 return in_java ? Handle_Exception(exceptionInfo, 2403 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)) 2404 : EXCEPTION_CONTINUE_EXECUTION; 2405 } else { 2406 // Fatal red zone violation. 2407 thread->disable_stack_red_zone(); 2408 tty->print_raw_cr("An unrecoverable stack overflow has occurred."); 2409 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2410 exceptionInfo->ContextRecord); 2411 return EXCEPTION_CONTINUE_SEARCH; 2412 } 2413 } else if (in_java) { 2414 // JVM-managed guard pages cannot be used on win95/98. The o/s provides 2415 // a one-time-only guard page, which it has released to us. The next 2416 // stack overflow on this thread will result in an ACCESS_VIOLATION. 2417 return Handle_Exception(exceptionInfo, 2418 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2419 } else { 2420 // Can only return and hope for the best. Further stack growth will 2421 // result in an ACCESS_VIOLATION. 2422 return EXCEPTION_CONTINUE_EXECUTION; 2423 } 2424 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2425 // Either stack overflow or null pointer exception. 2426 if (in_java) { 2427 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2428 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2429 address stack_end = thread->stack_base() - thread->stack_size(); 2430 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) { 2431 // Stack overflow. 2432 assert(!os::uses_stack_guard_pages(), 2433 "should be caught by red zone code above."); 2434 return Handle_Exception(exceptionInfo, 2435 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2436 } 2437 // 2438 // Check for safepoint polling and implicit null 2439 // We only expect null pointers in the stubs (vtable) 2440 // the rest are checked explicitly now. 2441 // 2442 CodeBlob* cb = CodeCache::find_blob(pc); 2443 if (cb != NULL) { 2444 if (os::is_poll_address(addr)) { 2445 address stub = SharedRuntime::get_poll_stub(pc); 2446 return Handle_Exception(exceptionInfo, stub); 2447 } 2448 } 2449 { 2450#ifdef _WIN64 2451 // 2452 // If it's a legal stack address map the entire region in 2453 // 2454 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord; 2455 address addr = (address) exceptionRecord->ExceptionInformation[1]; 2456 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) { 2457 addr = (address)((uintptr_t)addr & 2458 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1))); 2459 os::commit_memory((char *)addr, thread->stack_base() - addr, 2460 false ); 2461 return EXCEPTION_CONTINUE_EXECUTION; 2462 } 2463 else 2464#endif 2465 { 2466 // Null pointer exception. 2467#ifdef _M_IA64 2468 // We catch register stack overflows in compiled code by doing 2469 // an explicit compare and executing a st8(G0, G0) if the 2470 // BSP enters into our guard area. We test for the overflow 2471 // condition and fall into the normal null pointer exception 2472 // code if BSP hasn't overflowed. 2473 if ( in_java ) { 2474 if(thread->register_stack_overflow()) { 2475 assert((address)exceptionInfo->ContextRecord->IntS3 == 2476 thread->register_stack_limit(), 2477 "GR7 doesn't contain register_stack_limit"); 2478 // Disable the yellow zone which sets the state that 2479 // we've got a stack overflow problem. 2480 if (thread->stack_yellow_zone_enabled()) { 2481 thread->disable_stack_yellow_zone(); 2482 } 2483 // Give us some room to process the exception 2484 thread->disable_register_stack_guard(); 2485 // Update GR7 with the new limit so we can continue running 2486 // compiled code. 2487 exceptionInfo->ContextRecord->IntS3 = 2488 (ULONGLONG)thread->register_stack_limit(); 2489 return Handle_Exception(exceptionInfo, 2490 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW)); 2491 } else { 2492 // 2493 // Check for implicit null 2494 // We only expect null pointers in the stubs (vtable) 2495 // the rest are checked explicitly now. 2496 // 2497 if (((uintptr_t)addr) < os::vm_page_size() ) { 2498 // an access to the first page of VM--assume it is a null pointer 2499 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); 2500 if (stub != NULL) return Handle_Exception(exceptionInfo, stub); 2501 } 2502 } 2503 } // in_java 2504 2505 // IA64 doesn't use implicit null checking yet. So we shouldn't 2506 // get here. 2507 tty->print_raw_cr("Access violation, possible null pointer exception"); 2508 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2509 exceptionInfo->ContextRecord); 2510 return EXCEPTION_CONTINUE_SEARCH; 2511#else /* !IA64 */ 2512 2513 // Windows 98 reports faulting addresses incorrectly 2514 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) || 2515 !os::win32::is_nt()) { 2516 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); 2517 if (stub != NULL) return Handle_Exception(exceptionInfo, stub); 2518 } 2519 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2520 exceptionInfo->ContextRecord); 2521 return EXCEPTION_CONTINUE_SEARCH; 2522#endif 2523 } 2524 } 2525 } 2526 2527#ifdef _WIN64 2528 // Special care for fast JNI field accessors. 2529 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks 2530 // in and the heap gets shrunk before the field access. 2531 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2532 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2533 if (addr != (address)-1) { 2534 return Handle_Exception(exceptionInfo, addr); 2535 } 2536 } 2537#endif 2538 2539#ifdef _WIN64 2540 // Windows will sometimes generate an access violation 2541 // when we call malloc. Since we use VectoredExceptions 2542 // on 64 bit platforms, we see this exception. We must 2543 // pass this exception on so Windows can recover. 2544 // We check to see if the pc of the fault is in NTDLL.DLL 2545 // if so, we pass control on to Windows for handling. 2546 if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH; 2547#endif 2548 2549 // Stack overflow or null pointer exception in native code. 2550 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2551 exceptionInfo->ContextRecord); 2552 return EXCEPTION_CONTINUE_SEARCH; 2553 } 2554 2555 if (in_java) { 2556 switch (exception_code) { 2557 case EXCEPTION_INT_DIVIDE_BY_ZERO: 2558 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO)); 2559 2560 case EXCEPTION_INT_OVERFLOW: 2561 return Handle_IDiv_Exception(exceptionInfo); 2562 2563 } // switch 2564 } 2565#ifndef _WIN64 2566 if (((thread->thread_state() == _thread_in_Java) || 2567 (thread->thread_state() == _thread_in_native)) && 2568 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) 2569 { 2570 LONG result=Handle_FLT_Exception(exceptionInfo); 2571 if (result==EXCEPTION_CONTINUE_EXECUTION) return result; 2572 } 2573#endif //_WIN64 2574 } 2575 2576 if (exception_code != EXCEPTION_BREAKPOINT) { 2577#ifndef _WIN64 2578 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2579 exceptionInfo->ContextRecord); 2580#else 2581 // Itanium Windows uses a VectoredExceptionHandler 2582 // Which means that C++ programatic exception handlers (try/except) 2583 // will get here. Continue the search for the right except block if 2584 // the exception code is not a fatal code. 2585 switch ( exception_code ) { 2586 case EXCEPTION_ACCESS_VIOLATION: 2587 case EXCEPTION_STACK_OVERFLOW: 2588 case EXCEPTION_ILLEGAL_INSTRUCTION: 2589 case EXCEPTION_ILLEGAL_INSTRUCTION_2: 2590 case EXCEPTION_INT_OVERFLOW: 2591 case EXCEPTION_INT_DIVIDE_BY_ZERO: 2592 case EXCEPTION_UNCAUGHT_CXX_EXCEPTION: 2593 { report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord, 2594 exceptionInfo->ContextRecord); 2595 } 2596 break; 2597 default: 2598 break; 2599 } 2600#endif 2601 } 2602 return EXCEPTION_CONTINUE_SEARCH; 2603} 2604 2605#ifndef _WIN64 2606// Special care for fast JNI accessors. 2607// jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and 2608// the heap gets shrunk before the field access. 2609// Need to install our own structured exception handler since native code may 2610// install its own. 2611LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) { 2612 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode; 2613 if (exception_code == EXCEPTION_ACCESS_VIOLATION) { 2614 address pc = (address) exceptionInfo->ContextRecord->Eip; 2615 address addr = JNI_FastGetField::find_slowcase_pc(pc); 2616 if (addr != (address)-1) { 2617 return Handle_Exception(exceptionInfo, addr); 2618 } 2619 } 2620 return EXCEPTION_CONTINUE_SEARCH; 2621} 2622 2623#define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \ 2624Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \ 2625 __try { \ 2626 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \ 2627 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \ 2628 } \ 2629 return 0; \ 2630} 2631 2632DEFINE_FAST_GETFIELD(jboolean, bool, Boolean) 2633DEFINE_FAST_GETFIELD(jbyte, byte, Byte) 2634DEFINE_FAST_GETFIELD(jchar, char, Char) 2635DEFINE_FAST_GETFIELD(jshort, short, Short) 2636DEFINE_FAST_GETFIELD(jint, int, Int) 2637DEFINE_FAST_GETFIELD(jlong, long, Long) 2638DEFINE_FAST_GETFIELD(jfloat, float, Float) 2639DEFINE_FAST_GETFIELD(jdouble, double, Double) 2640 2641address os::win32::fast_jni_accessor_wrapper(BasicType type) { 2642 switch (type) { 2643 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper; 2644 case T_BYTE: return (address)jni_fast_GetByteField_wrapper; 2645 case T_CHAR: return (address)jni_fast_GetCharField_wrapper; 2646 case T_SHORT: return (address)jni_fast_GetShortField_wrapper; 2647 case T_INT: return (address)jni_fast_GetIntField_wrapper; 2648 case T_LONG: return (address)jni_fast_GetLongField_wrapper; 2649 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper; 2650 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper; 2651 default: ShouldNotReachHere(); 2652 } 2653 return (address)-1; 2654} 2655#endif 2656 2657// Virtual Memory 2658 2659int os::vm_page_size() { return os::win32::vm_page_size(); } 2660int os::vm_allocation_granularity() { 2661 return os::win32::vm_allocation_granularity(); 2662} 2663 2664// Windows large page support is available on Windows 2003. In order to use 2665// large page memory, the administrator must first assign additional privilege 2666// to the user: 2667// + select Control Panel -> Administrative Tools -> Local Security Policy 2668// + select Local Policies -> User Rights Assignment 2669// + double click "Lock pages in memory", add users and/or groups 2670// + reboot 2671// Note the above steps are needed for administrator as well, as administrators 2672// by default do not have the privilege to lock pages in memory. 2673// 2674// Note about Windows 2003: although the API supports committing large page 2675// memory on a page-by-page basis and VirtualAlloc() returns success under this 2676// scenario, I found through experiment it only uses large page if the entire 2677// memory region is reserved and committed in a single VirtualAlloc() call. 2678// This makes Windows large page support more or less like Solaris ISM, in 2679// that the entire heap must be committed upfront. This probably will change 2680// in the future, if so the code below needs to be revisited. 2681 2682#ifndef MEM_LARGE_PAGES 2683#define MEM_LARGE_PAGES 0x20000000 2684#endif 2685 2686// GetLargePageMinimum is only available on Windows 2003. The other functions 2687// are available on NT but not on Windows 98/Me. We have to resolve them at 2688// runtime. 2689typedef SIZE_T (WINAPI *GetLargePageMinimum_func_type) (void); 2690typedef BOOL (WINAPI *AdjustTokenPrivileges_func_type) 2691 (HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 2692typedef BOOL (WINAPI *OpenProcessToken_func_type) (HANDLE, DWORD, PHANDLE); 2693typedef BOOL (WINAPI *LookupPrivilegeValue_func_type) (LPCTSTR, LPCTSTR, PLUID); 2694 2695static GetLargePageMinimum_func_type _GetLargePageMinimum; 2696static AdjustTokenPrivileges_func_type _AdjustTokenPrivileges; 2697static OpenProcessToken_func_type _OpenProcessToken; 2698static LookupPrivilegeValue_func_type _LookupPrivilegeValue; 2699 2700static HINSTANCE _kernel32; 2701static HINSTANCE _advapi32; 2702static HANDLE _hProcess; 2703static HANDLE _hToken; 2704 2705static size_t _large_page_size = 0; 2706 2707static bool resolve_functions_for_large_page_init() { 2708 _kernel32 = LoadLibrary("kernel32.dll"); 2709 if (_kernel32 == NULL) return false; 2710 2711 _GetLargePageMinimum = CAST_TO_FN_PTR(GetLargePageMinimum_func_type, 2712 GetProcAddress(_kernel32, "GetLargePageMinimum")); 2713 if (_GetLargePageMinimum == NULL) return false; 2714 2715 _advapi32 = LoadLibrary("advapi32.dll"); 2716 if (_advapi32 == NULL) return false; 2717 2718 _AdjustTokenPrivileges = CAST_TO_FN_PTR(AdjustTokenPrivileges_func_type, 2719 GetProcAddress(_advapi32, "AdjustTokenPrivileges")); 2720 _OpenProcessToken = CAST_TO_FN_PTR(OpenProcessToken_func_type, 2721 GetProcAddress(_advapi32, "OpenProcessToken")); 2722 _LookupPrivilegeValue = CAST_TO_FN_PTR(LookupPrivilegeValue_func_type, 2723 GetProcAddress(_advapi32, "LookupPrivilegeValueA")); 2724 return _AdjustTokenPrivileges != NULL && 2725 _OpenProcessToken != NULL && 2726 _LookupPrivilegeValue != NULL; 2727} 2728 2729static bool request_lock_memory_privilege() { 2730 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, 2731 os::current_process_id()); 2732 2733 LUID luid; 2734 if (_hProcess != NULL && 2735 _OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) && 2736 _LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) { 2737 2738 TOKEN_PRIVILEGES tp; 2739 tp.PrivilegeCount = 1; 2740 tp.Privileges[0].Luid = luid; 2741 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 2742 2743 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the 2744 // privilege. Check GetLastError() too. See MSDN document. 2745 if (_AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) && 2746 (GetLastError() == ERROR_SUCCESS)) { 2747 return true; 2748 } 2749 } 2750 2751 return false; 2752} 2753 2754static void cleanup_after_large_page_init() { 2755 _GetLargePageMinimum = NULL; 2756 _AdjustTokenPrivileges = NULL; 2757 _OpenProcessToken = NULL; 2758 _LookupPrivilegeValue = NULL; 2759 if (_kernel32) FreeLibrary(_kernel32); 2760 _kernel32 = NULL; 2761 if (_advapi32) FreeLibrary(_advapi32); 2762 _advapi32 = NULL; 2763 if (_hProcess) CloseHandle(_hProcess); 2764 _hProcess = NULL; 2765 if (_hToken) CloseHandle(_hToken); 2766 _hToken = NULL; 2767} 2768 2769void os::large_page_init() { 2770 if (!UseLargePages) return; 2771 2772 // print a warning if any large page related flag is specified on command line 2773 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 2774 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 2775 bool success = false; 2776 2777# define WARN(msg) if (warn_on_failure) { warning(msg); } 2778 if (resolve_functions_for_large_page_init()) { 2779 if (request_lock_memory_privilege()) { 2780 size_t s = _GetLargePageMinimum(); 2781 if (s) { 2782#if defined(IA32) || defined(AMD64) 2783 if (s > 4*M || LargePageSizeInBytes > 4*M) { 2784 WARN("JVM cannot use large pages bigger than 4mb."); 2785 } else { 2786#endif 2787 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) { 2788 _large_page_size = LargePageSizeInBytes; 2789 } else { 2790 _large_page_size = s; 2791 } 2792 success = true; 2793#if defined(IA32) || defined(AMD64) 2794 } 2795#endif 2796 } else { 2797 WARN("Large page is not supported by the processor."); 2798 } 2799 } else { 2800 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 2801 } 2802 } else { 2803 WARN("Large page is not supported by the operating system."); 2804 } 2805#undef WARN 2806 2807 const size_t default_page_size = (size_t) vm_page_size(); 2808 if (success && _large_page_size > default_page_size) { 2809 _page_sizes[0] = _large_page_size; 2810 _page_sizes[1] = default_page_size; 2811 _page_sizes[2] = 0; 2812 } 2813 2814 cleanup_after_large_page_init(); 2815 UseLargePages = success; 2816} 2817 2818// On win32, one cannot release just a part of reserved memory, it's an 2819// all or nothing deal. When we split a reservation, we must break the 2820// reservation into two reservations. 2821void os::split_reserved_memory(char *base, size_t size, size_t split, 2822 bool realloc) { 2823 if (size > 0) { 2824 release_memory(base, size); 2825 if (realloc) { 2826 reserve_memory(split, base); 2827 } 2828 if (size != split) { 2829 reserve_memory(size - split, base + split); 2830 } 2831 } 2832} 2833 2834char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 2835 assert((size_t)addr % os::vm_allocation_granularity() == 0, 2836 "reserve alignment"); 2837 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size"); 2838 char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 2839 assert(res == NULL || addr == NULL || addr == res, 2840 "Unexpected address from reserve."); 2841 return res; 2842} 2843 2844// Reserve memory at an arbitrary address, only if that area is 2845// available (and not reserved for something else). 2846char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2847 // Windows os::reserve_memory() fails of the requested address range is 2848 // not avilable. 2849 return reserve_memory(bytes, requested_addr); 2850} 2851 2852size_t os::large_page_size() { 2853 return _large_page_size; 2854} 2855 2856bool os::can_commit_large_page_memory() { 2857 // Windows only uses large page memory when the entire region is reserved 2858 // and committed in a single VirtualAlloc() call. This may change in the 2859 // future, but with Windows 2003 it's not possible to commit on demand. 2860 return false; 2861} 2862 2863bool os::can_execute_large_page_memory() { 2864 return true; 2865} 2866 2867char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) { 2868 2869 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 2870 2871 if (UseLargePagesIndividualAllocation) { 2872 if (TracePageSizes && Verbose) { 2873 tty->print_cr("Reserving large pages individually."); 2874 } 2875 char * p_buf; 2876 // first reserve enough address space in advance since we want to be 2877 // able to break a single contiguous virtual address range into multiple 2878 // large page commits but WS2003 does not allow reserving large page space 2879 // so we just use 4K pages for reserve, this gives us a legal contiguous 2880 // address space. then we will deallocate that reservation, and re alloc 2881 // using large pages 2882 const size_t size_of_reserve = bytes + _large_page_size; 2883 if (bytes > size_of_reserve) { 2884 // Overflowed. 2885 warning("Individually allocated large pages failed, " 2886 "use -XX:-UseLargePagesIndividualAllocation to turn off"); 2887 return NULL; 2888 } 2889 p_buf = (char *) VirtualAlloc(addr, 2890 size_of_reserve, // size of Reserve 2891 MEM_RESERVE, 2892 PAGE_READWRITE); 2893 // If reservation failed, return NULL 2894 if (p_buf == NULL) return NULL; 2895 2896 release_memory(p_buf, bytes + _large_page_size); 2897 // round up to page boundary. If the size_of_reserve did not 2898 // overflow and the reservation did not fail, this align up 2899 // should not overflow. 2900 p_buf = (char *) align_size_up((size_t)p_buf, _large_page_size); 2901 2902 // now go through and allocate one page at a time until all bytes are 2903 // allocated 2904 size_t bytes_remaining = align_size_up(bytes, _large_page_size); 2905 // An overflow of align_size_up() would have been caught above 2906 // in the calculation of size_of_reserve. 2907 char * next_alloc_addr = p_buf; 2908 2909#ifdef ASSERT 2910 // Variable for the failure injection 2911 long ran_num = os::random(); 2912 size_t fail_after = ran_num % bytes; 2913#endif 2914 2915 while (bytes_remaining) { 2916 size_t bytes_to_rq = MIN2(bytes_remaining, _large_page_size); 2917 // Note allocate and commit 2918 char * p_new; 2919 2920#ifdef ASSERT 2921 bool inject_error = LargePagesIndividualAllocationInjectError && 2922 (bytes_remaining <= fail_after); 2923#else 2924 const bool inject_error = false; 2925#endif 2926 2927 if (inject_error) { 2928 p_new = NULL; 2929 } else { 2930 p_new = (char *) VirtualAlloc(next_alloc_addr, 2931 bytes_to_rq, 2932 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, 2933 prot); 2934 } 2935 2936 if (p_new == NULL) { 2937 // Free any allocated pages 2938 if (next_alloc_addr > p_buf) { 2939 // Some memory was committed so release it. 2940 size_t bytes_to_release = bytes - bytes_remaining; 2941 release_memory(p_buf, bytes_to_release); 2942 } 2943#ifdef ASSERT 2944 if (UseLargePagesIndividualAllocation && 2945 LargePagesIndividualAllocationInjectError) { 2946 if (TracePageSizes && Verbose) { 2947 tty->print_cr("Reserving large pages individually failed."); 2948 } 2949 } 2950#endif 2951 return NULL; 2952 } 2953 bytes_remaining -= bytes_to_rq; 2954 next_alloc_addr += bytes_to_rq; 2955 } 2956 2957 return p_buf; 2958 2959 } else { 2960 // normal policy just allocate it all at once 2961 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 2962 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot); 2963 return res; 2964 } 2965} 2966 2967bool os::release_memory_special(char* base, size_t bytes) { 2968 return release_memory(base, bytes); 2969} 2970 2971void os::print_statistics() { 2972} 2973 2974bool os::commit_memory(char* addr, size_t bytes, bool exec) { 2975 if (bytes == 0) { 2976 // Don't bother the OS with noops. 2977 return true; 2978 } 2979 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries"); 2980 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks"); 2981 // Don't attempt to print anything if the OS call fails. We're 2982 // probably low on resources, so the print itself may cause crashes. 2983 bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0; 2984 if (result != NULL && exec) { 2985 DWORD oldprot; 2986 // Windows doc says to use VirtualProtect to get execute permissions 2987 return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0; 2988 } else { 2989 return result; 2990 } 2991} 2992 2993bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 2994 bool exec) { 2995 return commit_memory(addr, size, exec); 2996} 2997 2998bool os::uncommit_memory(char* addr, size_t bytes) { 2999 if (bytes == 0) { 3000 // Don't bother the OS with noops. 3001 return true; 3002 } 3003 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries"); 3004 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks"); 3005 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0; 3006} 3007 3008bool os::release_memory(char* addr, size_t bytes) { 3009 return VirtualFree(addr, 0, MEM_RELEASE) != 0; 3010} 3011 3012bool os::create_stack_guard_pages(char* addr, size_t size) { 3013 return os::commit_memory(addr, size); 3014} 3015 3016bool os::remove_stack_guard_pages(char* addr, size_t size) { 3017 return os::uncommit_memory(addr, size); 3018} 3019 3020// Set protections specified 3021bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 3022 bool is_committed) { 3023 unsigned int p = 0; 3024 switch (prot) { 3025 case MEM_PROT_NONE: p = PAGE_NOACCESS; break; 3026 case MEM_PROT_READ: p = PAGE_READONLY; break; 3027 case MEM_PROT_RW: p = PAGE_READWRITE; break; 3028 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break; 3029 default: 3030 ShouldNotReachHere(); 3031 } 3032 3033 DWORD old_status; 3034 3035 // Strange enough, but on Win32 one can change protection only for committed 3036 // memory, not a big deal anyway, as bytes less or equal than 64K 3037 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) { 3038 fatal("cannot commit protection page"); 3039 } 3040 // One cannot use os::guard_memory() here, as on Win32 guard page 3041 // have different (one-shot) semantics, from MSDN on PAGE_GUARD: 3042 // 3043 // Pages in the region become guard pages. Any attempt to access a guard page 3044 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off 3045 // the guard page status. Guard pages thus act as a one-time access alarm. 3046 return VirtualProtect(addr, bytes, p, &old_status) != 0; 3047} 3048 3049bool os::guard_memory(char* addr, size_t bytes) { 3050 DWORD old_status; 3051 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0; 3052} 3053 3054bool os::unguard_memory(char* addr, size_t bytes) { 3055 DWORD old_status; 3056 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0; 3057} 3058 3059void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } 3060void os::free_memory(char *addr, size_t bytes) { } 3061void os::numa_make_global(char *addr, size_t bytes) { } 3062void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } 3063bool os::numa_topology_changed() { return false; } 3064size_t os::numa_get_groups_num() { return 1; } 3065int os::numa_get_group_id() { return 0; } 3066size_t os::numa_get_leaf_groups(int *ids, size_t size) { 3067 if (size > 0) { 3068 ids[0] = 0; 3069 return 1; 3070 } 3071 return 0; 3072} 3073 3074bool os::get_page_info(char *start, page_info* info) { 3075 return false; 3076} 3077 3078char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 3079 return end; 3080} 3081 3082char* os::non_memory_address_word() { 3083 // Must never look like an address returned by reserve_memory, 3084 // even in its subfields (as defined by the CPU immediate fields, 3085 // if the CPU splits constants across multiple instructions). 3086 return (char*)-1; 3087} 3088 3089#define MAX_ERROR_COUNT 100 3090#define SYS_THREAD_ERROR 0xffffffffUL 3091 3092void os::pd_start_thread(Thread* thread) { 3093 DWORD ret = ResumeThread(thread->osthread()->thread_handle()); 3094 // Returns previous suspend state: 3095 // 0: Thread was not suspended 3096 // 1: Thread is running now 3097 // >1: Thread is still suspended. 3098 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back 3099} 3100 3101class HighResolutionInterval { 3102 // The default timer resolution seems to be 10 milliseconds. 3103 // (Where is this written down?) 3104 // If someone wants to sleep for only a fraction of the default, 3105 // then we set the timer resolution down to 1 millisecond for 3106 // the duration of their interval. 3107 // We carefully set the resolution back, since otherwise we 3108 // seem to incur an overhead (3%?) that we don't need. 3109 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time. 3110 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod(). 3111 // Alternatively, we could compute the relative error (503/500 = .6%) and only use 3112 // timeBeginPeriod() if the relative error exceeded some threshold. 3113 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and 3114 // to decreased efficiency related to increased timer "tick" rates. We want to minimize 3115 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high 3116 // resolution timers running. 3117private: 3118 jlong resolution; 3119public: 3120 HighResolutionInterval(jlong ms) { 3121 resolution = ms % 10L; 3122 if (resolution != 0) { 3123 MMRESULT result = timeBeginPeriod(1L); 3124 } 3125 } 3126 ~HighResolutionInterval() { 3127 if (resolution != 0) { 3128 MMRESULT result = timeEndPeriod(1L); 3129 } 3130 resolution = 0L; 3131 } 3132}; 3133 3134int os::sleep(Thread* thread, jlong ms, bool interruptable) { 3135 jlong limit = (jlong) MAXDWORD; 3136 3137 while(ms > limit) { 3138 int res; 3139 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) 3140 return res; 3141 ms -= limit; 3142 } 3143 3144 assert(thread == Thread::current(), "thread consistency check"); 3145 OSThread* osthread = thread->osthread(); 3146 OSThreadWaitState osts(osthread, false /* not Object.wait() */); 3147 int result; 3148 if (interruptable) { 3149 assert(thread->is_Java_thread(), "must be java thread"); 3150 JavaThread *jt = (JavaThread *) thread; 3151 ThreadBlockInVM tbivm(jt); 3152 3153 jt->set_suspend_equivalent(); 3154 // cleared by handle_special_suspend_equivalent_condition() or 3155 // java_suspend_self() via check_and_wait_while_suspended() 3156 3157 HANDLE events[1]; 3158 events[0] = osthread->interrupt_event(); 3159 HighResolutionInterval *phri=NULL; 3160 if(!ForceTimeHighResolution) 3161 phri = new HighResolutionInterval( ms ); 3162 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) { 3163 result = OS_TIMEOUT; 3164 } else { 3165 ResetEvent(osthread->interrupt_event()); 3166 osthread->set_interrupted(false); 3167 result = OS_INTRPT; 3168 } 3169 delete phri; //if it is NULL, harmless 3170 3171 // were we externally suspended while we were waiting? 3172 jt->check_and_wait_while_suspended(); 3173 } else { 3174 assert(!thread->is_Java_thread(), "must not be java thread"); 3175 Sleep((long) ms); 3176 result = OS_TIMEOUT; 3177 } 3178 return result; 3179} 3180 3181// Sleep forever; naked call to OS-specific sleep; use with CAUTION 3182void os::infinite_sleep() { 3183 while (true) { // sleep forever ... 3184 Sleep(100000); // ... 100 seconds at a time 3185 } 3186} 3187 3188typedef BOOL (WINAPI * STTSignature)(void) ; 3189 3190os::YieldResult os::NakedYield() { 3191 // Use either SwitchToThread() or Sleep(0) 3192 // Consider passing back the return value from SwitchToThread(). 3193 // We use GetProcAddress() as ancient Win9X versions of windows doen't support SwitchToThread. 3194 // In that case we revert to Sleep(0). 3195 static volatile STTSignature stt = (STTSignature) 1 ; 3196 3197 if (stt == ((STTSignature) 1)) { 3198 stt = (STTSignature) ::GetProcAddress (LoadLibrary ("Kernel32.dll"), "SwitchToThread") ; 3199 // It's OK if threads race during initialization as the operation above is idempotent. 3200 } 3201 if (stt != NULL) { 3202 return (*stt)() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ; 3203 } else { 3204 Sleep (0) ; 3205 } 3206 return os::YIELD_UNKNOWN ; 3207} 3208 3209void os::yield() { os::NakedYield(); } 3210 3211void os::yield_all(int attempts) { 3212 // Yields to all threads, including threads with lower priorities 3213 Sleep(1); 3214} 3215 3216// Win32 only gives you access to seven real priorities at a time, 3217// so we compress Java's ten down to seven. It would be better 3218// if we dynamically adjusted relative priorities. 3219 3220int os::java_to_os_priority[MaxPriority + 1] = { 3221 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3222 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3223 THREAD_PRIORITY_LOWEST, // 2 3224 THREAD_PRIORITY_BELOW_NORMAL, // 3 3225 THREAD_PRIORITY_BELOW_NORMAL, // 4 3226 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3227 THREAD_PRIORITY_NORMAL, // 6 3228 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3229 THREAD_PRIORITY_ABOVE_NORMAL, // 8 3230 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3231 THREAD_PRIORITY_HIGHEST // 10 MaxPriority 3232}; 3233 3234int prio_policy1[MaxPriority + 1] = { 3235 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3236 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3237 THREAD_PRIORITY_LOWEST, // 2 3238 THREAD_PRIORITY_BELOW_NORMAL, // 3 3239 THREAD_PRIORITY_BELOW_NORMAL, // 4 3240 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3241 THREAD_PRIORITY_ABOVE_NORMAL, // 6 3242 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3243 THREAD_PRIORITY_HIGHEST, // 8 3244 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3245 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority 3246}; 3247 3248static int prio_init() { 3249 // If ThreadPriorityPolicy is 1, switch tables 3250 if (ThreadPriorityPolicy == 1) { 3251 int i; 3252 for (i = 0; i < MaxPriority + 1; i++) { 3253 os::java_to_os_priority[i] = prio_policy1[i]; 3254 } 3255 } 3256 return 0; 3257} 3258 3259OSReturn os::set_native_priority(Thread* thread, int priority) { 3260 if (!UseThreadPriorities) return OS_OK; 3261 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0; 3262 return ret ? OS_OK : OS_ERR; 3263} 3264 3265OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) { 3266 if ( !UseThreadPriorities ) { 3267 *priority_ptr = java_to_os_priority[NormPriority]; 3268 return OS_OK; 3269 } 3270 int os_prio = GetThreadPriority(thread->osthread()->thread_handle()); 3271 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) { 3272 assert(false, "GetThreadPriority failed"); 3273 return OS_ERR; 3274 } 3275 *priority_ptr = os_prio; 3276 return OS_OK; 3277} 3278 3279 3280// Hint to the underlying OS that a task switch would not be good. 3281// Void return because it's a hint and can fail. 3282void os::hint_no_preempt() {} 3283 3284void os::interrupt(Thread* thread) { 3285 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3286 "possibility of dangling Thread pointer"); 3287 3288 OSThread* osthread = thread->osthread(); 3289 osthread->set_interrupted(true); 3290 // More than one thread can get here with the same value of osthread, 3291 // resulting in multiple notifications. We do, however, want the store 3292 // to interrupted() to be visible to other threads before we post 3293 // the interrupt event. 3294 OrderAccess::release(); 3295 SetEvent(osthread->interrupt_event()); 3296 // For JSR166: unpark after setting status 3297 if (thread->is_Java_thread()) 3298 ((JavaThread*)thread)->parker()->unpark(); 3299 3300 ParkEvent * ev = thread->_ParkEvent ; 3301 if (ev != NULL) ev->unpark() ; 3302 3303} 3304 3305 3306bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 3307 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3308 "possibility of dangling Thread pointer"); 3309 3310 OSThread* osthread = thread->osthread(); 3311 bool interrupted = osthread->interrupted(); 3312 // There is no synchronization between the setting of the interrupt 3313 // and it being cleared here. It is critical - see 6535709 - that 3314 // we only clear the interrupt state, and reset the interrupt event, 3315 // if we are going to report that we were indeed interrupted - else 3316 // an interrupt can be "lost", leading to spurious wakeups or lost wakeups 3317 // depending on the timing 3318 if (interrupted && clear_interrupted) { 3319 osthread->set_interrupted(false); 3320 ResetEvent(osthread->interrupt_event()); 3321 } // Otherwise leave the interrupted state alone 3322 3323 return interrupted; 3324} 3325 3326// Get's a pc (hint) for a running thread. Currently used only for profiling. 3327ExtendedPC os::get_thread_pc(Thread* thread) { 3328 CONTEXT context; 3329 context.ContextFlags = CONTEXT_CONTROL; 3330 HANDLE handle = thread->osthread()->thread_handle(); 3331#ifdef _M_IA64 3332 assert(0, "Fix get_thread_pc"); 3333 return ExtendedPC(NULL); 3334#else 3335 if (GetThreadContext(handle, &context)) { 3336#ifdef _M_AMD64 3337 return ExtendedPC((address) context.Rip); 3338#else 3339 return ExtendedPC((address) context.Eip); 3340#endif 3341 } else { 3342 return ExtendedPC(NULL); 3343 } 3344#endif 3345} 3346 3347// GetCurrentThreadId() returns DWORD 3348intx os::current_thread_id() { return GetCurrentThreadId(); } 3349 3350static int _initial_pid = 0; 3351 3352int os::current_process_id() 3353{ 3354 return (_initial_pid ? _initial_pid : _getpid()); 3355} 3356 3357int os::win32::_vm_page_size = 0; 3358int os::win32::_vm_allocation_granularity = 0; 3359int os::win32::_processor_type = 0; 3360// Processor level is not available on non-NT systems, use vm_version instead 3361int os::win32::_processor_level = 0; 3362julong os::win32::_physical_memory = 0; 3363size_t os::win32::_default_stack_size = 0; 3364 3365 intx os::win32::_os_thread_limit = 0; 3366volatile intx os::win32::_os_thread_count = 0; 3367 3368bool os::win32::_is_nt = false; 3369bool os::win32::_is_windows_2003 = false; 3370bool os::win32::_is_windows_server = false; 3371 3372void os::win32::initialize_system_info() { 3373 SYSTEM_INFO si; 3374 GetSystemInfo(&si); 3375 _vm_page_size = si.dwPageSize; 3376 _vm_allocation_granularity = si.dwAllocationGranularity; 3377 _processor_type = si.dwProcessorType; 3378 _processor_level = si.wProcessorLevel; 3379 set_processor_count(si.dwNumberOfProcessors); 3380 3381 MEMORYSTATUSEX ms; 3382 ms.dwLength = sizeof(ms); 3383 3384 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual, 3385 // dwMemoryLoad (% of memory in use) 3386 GlobalMemoryStatusEx(&ms); 3387 _physical_memory = ms.ullTotalPhys; 3388 3389 OSVERSIONINFOEX oi; 3390 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 3391 GetVersionEx((OSVERSIONINFO*)&oi); 3392 switch(oi.dwPlatformId) { 3393 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break; 3394 case VER_PLATFORM_WIN32_NT: 3395 _is_nt = true; 3396 { 3397 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion; 3398 if (os_vers == 5002) { 3399 _is_windows_2003 = true; 3400 } 3401 if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER || 3402 oi.wProductType == VER_NT_SERVER) { 3403 _is_windows_server = true; 3404 } 3405 } 3406 break; 3407 default: fatal("Unknown platform"); 3408 } 3409 3410 _default_stack_size = os::current_stack_size(); 3411 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size"); 3412 assert((_default_stack_size & (_vm_page_size - 1)) == 0, 3413 "stack size not a multiple of page size"); 3414 3415 initialize_performance_counter(); 3416 3417 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is 3418 // known to deadlock the system, if the VM issues to thread operations with 3419 // a too high frequency, e.g., such as changing the priorities. 3420 // The 6000 seems to work well - no deadlocks has been notices on the test 3421 // programs that we have seen experience this problem. 3422 if (!os::win32::is_nt()) { 3423 StarvationMonitorInterval = 6000; 3424 } 3425} 3426 3427 3428void os::win32::setmode_streams() { 3429 _setmode(_fileno(stdin), _O_BINARY); 3430 _setmode(_fileno(stdout), _O_BINARY); 3431 _setmode(_fileno(stderr), _O_BINARY); 3432} 3433 3434 3435bool os::is_debugger_attached() { 3436 return IsDebuggerPresent() ? true : false; 3437} 3438 3439 3440void os::wait_for_keypress_at_exit(void) { 3441 if (PauseAtExit) { 3442 fprintf(stderr, "Press any key to continue...\n"); 3443 fgetc(stdin); 3444 } 3445} 3446 3447 3448int os::message_box(const char* title, const char* message) { 3449 int result = MessageBox(NULL, message, title, 3450 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY); 3451 return result == IDYES; 3452} 3453 3454int os::allocate_thread_local_storage() { 3455 return TlsAlloc(); 3456} 3457 3458 3459void os::free_thread_local_storage(int index) { 3460 TlsFree(index); 3461} 3462 3463 3464void os::thread_local_storage_at_put(int index, void* value) { 3465 TlsSetValue(index, value); 3466 assert(thread_local_storage_at(index) == value, "Just checking"); 3467} 3468 3469 3470void* os::thread_local_storage_at(int index) { 3471 return TlsGetValue(index); 3472} 3473 3474 3475#ifndef PRODUCT 3476#ifndef _WIN64 3477// Helpers to check whether NX protection is enabled 3478int nx_exception_filter(_EXCEPTION_POINTERS *pex) { 3479 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 3480 pex->ExceptionRecord->NumberParameters > 0 && 3481 pex->ExceptionRecord->ExceptionInformation[0] == 3482 EXCEPTION_INFO_EXEC_VIOLATION) { 3483 return EXCEPTION_EXECUTE_HANDLER; 3484 } 3485 return EXCEPTION_CONTINUE_SEARCH; 3486} 3487 3488void nx_check_protection() { 3489 // If NX is enabled we'll get an exception calling into code on the stack 3490 char code[] = { (char)0xC3 }; // ret 3491 void *code_ptr = (void *)code; 3492 __try { 3493 __asm call code_ptr 3494 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) { 3495 tty->print_raw_cr("NX protection detected."); 3496 } 3497} 3498#endif // _WIN64 3499#endif // PRODUCT 3500 3501// this is called _before_ the global arguments have been parsed 3502void os::init(void) { 3503 _initial_pid = _getpid(); 3504 3505 init_random(1234567); 3506 3507 win32::initialize_system_info(); 3508 win32::setmode_streams(); 3509 init_page_sizes((size_t) win32::vm_page_size()); 3510 3511 // For better scalability on MP systems (must be called after initialize_system_info) 3512#ifndef PRODUCT 3513 if (is_MP()) { 3514 NoYieldsInMicrolock = true; 3515 } 3516#endif 3517 // This may be overridden later when argument processing is done. 3518 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation, 3519 os::win32::is_windows_2003()); 3520 3521 // Initialize main_process and main_thread 3522 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle 3523 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process, 3524 &main_thread, THREAD_ALL_ACCESS, false, 0)) { 3525 fatal("DuplicateHandle failed\n"); 3526 } 3527 main_thread_id = (int) GetCurrentThreadId(); 3528} 3529 3530// To install functions for atexit processing 3531extern "C" { 3532 static void perfMemory_exit_helper() { 3533 perfMemory_exit(); 3534 } 3535} 3536 3537// this is called _after_ the global arguments have been parsed 3538jint os::init_2(void) { 3539 // Allocate a single page and mark it as readable for safepoint polling 3540 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY); 3541 guarantee( polling_page != NULL, "Reserve Failed for polling page"); 3542 3543 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY); 3544 guarantee( return_page != NULL, "Commit Failed for polling page"); 3545 3546 os::set_polling_page( polling_page ); 3547 3548#ifndef PRODUCT 3549 if( Verbose && PrintMiscellaneous ) 3550 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 3551#endif 3552 3553 if (!UseMembar) { 3554 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE); 3555 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page"); 3556 3557 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE); 3558 guarantee( return_page != NULL, "Commit Failed for memory serialize page"); 3559 3560 os::set_memory_serialize_page( mem_serialize_page ); 3561 3562#ifndef PRODUCT 3563 if(Verbose && PrintMiscellaneous) 3564 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 3565#endif 3566} 3567 3568 os::large_page_init(); 3569 3570 // Setup Windows Exceptions 3571 3572 // On Itanium systems, Structured Exception Handling does not 3573 // work since stack frames must be walkable by the OS. Since 3574 // much of our code is dynamically generated, and we do not have 3575 // proper unwind .xdata sections, the system simply exits 3576 // rather than delivering the exception. To work around 3577 // this we use VectorExceptions instead. 3578#ifdef _WIN64 3579 if (UseVectoredExceptions) { 3580 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter); 3581 } 3582#endif 3583 3584 // for debugging float code generation bugs 3585 if (ForceFloatExceptions) { 3586#ifndef _WIN64 3587 static long fp_control_word = 0; 3588 __asm { fstcw fp_control_word } 3589 // see Intel PPro Manual, Vol. 2, p 7-16 3590 const long precision = 0x20; 3591 const long underflow = 0x10; 3592 const long overflow = 0x08; 3593 const long zero_div = 0x04; 3594 const long denorm = 0x02; 3595 const long invalid = 0x01; 3596 fp_control_word |= invalid; 3597 __asm { fldcw fp_control_word } 3598#endif 3599 } 3600 3601 // If stack_commit_size is 0, windows will reserve the default size, 3602 // but only commit a small portion of it. 3603 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size()); 3604 size_t default_reserve_size = os::win32::default_stack_size(); 3605 size_t actual_reserve_size = stack_commit_size; 3606 if (stack_commit_size < default_reserve_size) { 3607 // If stack_commit_size == 0, we want this too 3608 actual_reserve_size = default_reserve_size; 3609 } 3610 3611 // Check minimum allowable stack size for thread creation and to initialize 3612 // the java system classes, including StackOverflowError - depends on page 3613 // size. Add a page for compiler2 recursion in main thread. 3614 // Add in 2*BytesPerWord times page size to account for VM stack during 3615 // class initialization depending on 32 or 64 bit VM. 3616 size_t min_stack_allowed = 3617 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ 3618 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size(); 3619 if (actual_reserve_size < min_stack_allowed) { 3620 tty->print_cr("\nThe stack size specified is too small, " 3621 "Specify at least %dk", 3622 min_stack_allowed / K); 3623 return JNI_ERR; 3624 } 3625 3626 JavaThread::set_stack_size_at_create(stack_commit_size); 3627 3628 // Calculate theoretical max. size of Threads to guard gainst artifical 3629 // out-of-memory situations, where all available address-space has been 3630 // reserved by thread stacks. 3631 assert(actual_reserve_size != 0, "Must have a stack"); 3632 3633 // Calculate the thread limit when we should start doing Virtual Memory 3634 // banging. Currently when the threads will have used all but 200Mb of space. 3635 // 3636 // TODO: consider performing a similar calculation for commit size instead 3637 // as reserve size, since on a 64-bit platform we'll run into that more 3638 // often than running out of virtual memory space. We can use the 3639 // lower value of the two calculations as the os_thread_limit. 3640 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K); 3641 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size); 3642 3643 // at exit methods are called in the reverse order of their registration. 3644 // there is no limit to the number of functions registered. atexit does 3645 // not set errno. 3646 3647 if (PerfAllowAtExitRegistration) { 3648 // only register atexit functions if PerfAllowAtExitRegistration is set. 3649 // atexit functions can be delayed until process exit time, which 3650 // can be problematic for embedded VM situations. Embedded VMs should 3651 // call DestroyJavaVM() to assure that VM resources are released. 3652 3653 // note: perfMemory_exit_helper atexit function may be removed in 3654 // the future if the appropriate cleanup code can be added to the 3655 // VM_Exit VMOperation's doit method. 3656 if (atexit(perfMemory_exit_helper) != 0) { 3657 warning("os::init_2 atexit(perfMemory_exit_helper) failed"); 3658 } 3659 } 3660 3661 // initialize PSAPI or ToolHelp for fatal error handler 3662 if (win32::is_nt()) _init_psapi(); 3663 else _init_toolhelp(); 3664 3665#ifndef _WIN64 3666 // Print something if NX is enabled (win32 on AMD64) 3667 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection()); 3668#endif 3669 3670 // initialize thread priority policy 3671 prio_init(); 3672 3673 if (UseNUMA && !ForceNUMA) { 3674 UseNUMA = false; // Currently unsupported. 3675 } 3676 3677 return JNI_OK; 3678} 3679 3680void os::init_3(void) { 3681 return; 3682} 3683 3684// Mark the polling page as unreadable 3685void os::make_polling_page_unreadable(void) { 3686 DWORD old_status; 3687 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) ) 3688 fatal("Could not disable polling page"); 3689}; 3690 3691// Mark the polling page as readable 3692void os::make_polling_page_readable(void) { 3693 DWORD old_status; 3694 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) ) 3695 fatal("Could not enable polling page"); 3696}; 3697 3698 3699int os::stat(const char *path, struct stat *sbuf) { 3700 char pathbuf[MAX_PATH]; 3701 if (strlen(path) > MAX_PATH - 1) { 3702 errno = ENAMETOOLONG; 3703 return -1; 3704 } 3705 os::native_path(strcpy(pathbuf, path)); 3706 int ret = ::stat(pathbuf, sbuf); 3707 if (sbuf != NULL && UseUTCFileTimestamp) { 3708 // Fix for 6539723. st_mtime returned from stat() is dependent on 3709 // the system timezone and so can return different values for the 3710 // same file if/when daylight savings time changes. This adjustment 3711 // makes sure the same timestamp is returned regardless of the TZ. 3712 // 3713 // See: 3714 // http://msdn.microsoft.com/library/ 3715 // default.asp?url=/library/en-us/sysinfo/base/ 3716 // time_zone_information_str.asp 3717 // and 3718 // http://msdn.microsoft.com/library/default.asp?url= 3719 // /library/en-us/sysinfo/base/settimezoneinformation.asp 3720 // 3721 // NOTE: there is a insidious bug here: If the timezone is changed 3722 // after the call to stat() but before 'GetTimeZoneInformation()', then 3723 // the adjustment we do here will be wrong and we'll return the wrong 3724 // value (which will likely end up creating an invalid class data 3725 // archive). Absent a better API for this, or some time zone locking 3726 // mechanism, we'll have to live with this risk. 3727 TIME_ZONE_INFORMATION tz; 3728 DWORD tzid = GetTimeZoneInformation(&tz); 3729 int daylightBias = 3730 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias; 3731 sbuf->st_mtime += (tz.Bias + daylightBias) * 60; 3732 } 3733 return ret; 3734} 3735 3736 3737#define FT2INT64(ft) \ 3738 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime)) 3739 3740 3741// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 3742// are used by JVM M&M and JVMTI to get user+sys or user CPU time 3743// of a thread. 3744// 3745// current_thread_cpu_time() and thread_cpu_time(Thread*) returns 3746// the fast estimate available on the platform. 3747 3748// current_thread_cpu_time() is not optimized for Windows yet 3749jlong os::current_thread_cpu_time() { 3750 // return user + sys since the cost is the same 3751 return os::thread_cpu_time(Thread::current(), true /* user+sys */); 3752} 3753 3754jlong os::thread_cpu_time(Thread* thread) { 3755 // consistent with what current_thread_cpu_time() returns. 3756 return os::thread_cpu_time(thread, true /* user+sys */); 3757} 3758 3759jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 3760 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 3761} 3762 3763jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) { 3764 // This code is copy from clasic VM -> hpi::sysThreadCPUTime 3765 // If this function changes, os::is_thread_cpu_time_supported() should too 3766 if (os::win32::is_nt()) { 3767 FILETIME CreationTime; 3768 FILETIME ExitTime; 3769 FILETIME KernelTime; 3770 FILETIME UserTime; 3771 3772 if ( GetThreadTimes(thread->osthread()->thread_handle(), 3773 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3774 return -1; 3775 else 3776 if (user_sys_cpu_time) { 3777 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100; 3778 } else { 3779 return FT2INT64(UserTime) * 100; 3780 } 3781 } else { 3782 return (jlong) timeGetTime() * 1000000; 3783 } 3784} 3785 3786void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3787 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3788 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3789 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3790 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3791} 3792 3793void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3794 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3795 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3796 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3797 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3798} 3799 3800bool os::is_thread_cpu_time_supported() { 3801 // see os::thread_cpu_time 3802 if (os::win32::is_nt()) { 3803 FILETIME CreationTime; 3804 FILETIME ExitTime; 3805 FILETIME KernelTime; 3806 FILETIME UserTime; 3807 3808 if ( GetThreadTimes(GetCurrentThread(), 3809 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3810 return false; 3811 else 3812 return true; 3813 } else { 3814 return false; 3815 } 3816} 3817 3818// Windows does't provide a loadavg primitive so this is stubbed out for now. 3819// It does have primitives (PDH API) to get CPU usage and run queue length. 3820// "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length" 3821// If we wanted to implement loadavg on Windows, we have a few options: 3822// 3823// a) Query CPU usage and run queue length and "fake" an answer by 3824// returning the CPU usage if it's under 100%, and the run queue 3825// length otherwise. It turns out that querying is pretty slow 3826// on Windows, on the order of 200 microseconds on a fast machine. 3827// Note that on the Windows the CPU usage value is the % usage 3828// since the last time the API was called (and the first call 3829// returns 100%), so we'd have to deal with that as well. 3830// 3831// b) Sample the "fake" answer using a sampling thread and store 3832// the answer in a global variable. The call to loadavg would 3833// just return the value of the global, avoiding the slow query. 3834// 3835// c) Sample a better answer using exponential decay to smooth the 3836// value. This is basically the algorithm used by UNIX kernels. 3837// 3838// Note that sampling thread starvation could affect both (b) and (c). 3839int os::loadavg(double loadavg[], int nelem) { 3840 return -1; 3841} 3842 3843 3844// DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield() 3845bool os::dont_yield() { 3846 return DontYieldALot; 3847} 3848 3849// This method is a slightly reworked copy of JDK's sysOpen 3850// from src/windows/hpi/src/sys_api_md.c 3851 3852int os::open(const char *path, int oflag, int mode) { 3853 char pathbuf[MAX_PATH]; 3854 3855 if (strlen(path) > MAX_PATH - 1) { 3856 errno = ENAMETOOLONG; 3857 return -1; 3858 } 3859 os::native_path(strcpy(pathbuf, path)); 3860 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode); 3861} 3862 3863// Is a (classpath) directory empty? 3864bool os::dir_is_empty(const char* path) { 3865 WIN32_FIND_DATA fd; 3866 HANDLE f = FindFirstFile(path, &fd); 3867 if (f == INVALID_HANDLE_VALUE) { 3868 return true; 3869 } 3870 FindClose(f); 3871 return false; 3872} 3873 3874// create binary file, rewriting existing file if required 3875int os::create_binary_file(const char* path, bool rewrite_existing) { 3876 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY; 3877 if (!rewrite_existing) { 3878 oflags |= _O_EXCL; 3879 } 3880 return ::open(path, oflags, _S_IREAD | _S_IWRITE); 3881} 3882 3883// return current position of file pointer 3884jlong os::current_file_offset(int fd) { 3885 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR); 3886} 3887 3888// move file pointer to the specified offset 3889jlong os::seek_to_file_offset(int fd, jlong offset) { 3890 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET); 3891} 3892 3893 3894jlong os::lseek(int fd, jlong offset, int whence) { 3895 return (jlong) ::_lseeki64(fd, offset, whence); 3896} 3897 3898// This method is a slightly reworked copy of JDK's sysNativePath 3899// from src/windows/hpi/src/path_md.c 3900 3901/* Convert a pathname to native format. On win32, this involves forcing all 3902 separators to be '\\' rather than '/' (both are legal inputs, but Win95 3903 sometimes rejects '/') and removing redundant separators. The input path is 3904 assumed to have been converted into the character encoding used by the local 3905 system. Because this might be a double-byte encoding, care is taken to 3906 treat double-byte lead characters correctly. 3907 3908 This procedure modifies the given path in place, as the result is never 3909 longer than the original. There is no error return; this operation always 3910 succeeds. */ 3911char * os::native_path(char *path) { 3912 char *src = path, *dst = path, *end = path; 3913 char *colon = NULL; /* If a drive specifier is found, this will 3914 point to the colon following the drive 3915 letter */ 3916 3917 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */ 3918 assert(((!::IsDBCSLeadByte('/')) 3919 && (!::IsDBCSLeadByte('\\')) 3920 && (!::IsDBCSLeadByte(':'))), 3921 "Illegal lead byte"); 3922 3923 /* Check for leading separators */ 3924#define isfilesep(c) ((c) == '/' || (c) == '\\') 3925 while (isfilesep(*src)) { 3926 src++; 3927 } 3928 3929 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') { 3930 /* Remove leading separators if followed by drive specifier. This 3931 hack is necessary to support file URLs containing drive 3932 specifiers (e.g., "file://c:/path"). As a side effect, 3933 "/c:/path" can be used as an alternative to "c:/path". */ 3934 *dst++ = *src++; 3935 colon = dst; 3936 *dst++ = ':'; 3937 src++; 3938 } else { 3939 src = path; 3940 if (isfilesep(src[0]) && isfilesep(src[1])) { 3941 /* UNC pathname: Retain first separator; leave src pointed at 3942 second separator so that further separators will be collapsed 3943 into the second separator. The result will be a pathname 3944 beginning with "\\\\" followed (most likely) by a host name. */ 3945 src = dst = path + 1; 3946 path[0] = '\\'; /* Force first separator to '\\' */ 3947 } 3948 } 3949 3950 end = dst; 3951 3952 /* Remove redundant separators from remainder of path, forcing all 3953 separators to be '\\' rather than '/'. Also, single byte space 3954 characters are removed from the end of the path because those 3955 are not legal ending characters on this operating system. 3956 */ 3957 while (*src != '\0') { 3958 if (isfilesep(*src)) { 3959 *dst++ = '\\'; src++; 3960 while (isfilesep(*src)) src++; 3961 if (*src == '\0') { 3962 /* Check for trailing separator */ 3963 end = dst; 3964 if (colon == dst - 2) break; /* "z:\\" */ 3965 if (dst == path + 1) break; /* "\\" */ 3966 if (dst == path + 2 && isfilesep(path[0])) { 3967 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the 3968 beginning of a UNC pathname. Even though it is not, by 3969 itself, a valid UNC pathname, we leave it as is in order 3970 to be consistent with the path canonicalizer as well 3971 as the win32 APIs, which treat this case as an invalid 3972 UNC pathname rather than as an alias for the root 3973 directory of the current drive. */ 3974 break; 3975 } 3976 end = --dst; /* Path does not denote a root directory, so 3977 remove trailing separator */ 3978 break; 3979 } 3980 end = dst; 3981 } else { 3982 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */ 3983 *dst++ = *src++; 3984 if (*src) *dst++ = *src++; 3985 end = dst; 3986 } else { /* Copy a single-byte character */ 3987 char c = *src++; 3988 *dst++ = c; 3989 /* Space is not a legal ending character */ 3990 if (c != ' ') end = dst; 3991 } 3992 } 3993 } 3994 3995 *end = '\0'; 3996 3997 /* For "z:", add "." to work around a bug in the C runtime library */ 3998 if (colon == dst - 1) { 3999 path[2] = '.'; 4000 path[3] = '\0'; 4001 } 4002 4003 #ifdef DEBUG 4004 jio_fprintf(stderr, "sysNativePath: %s\n", path); 4005 #endif DEBUG 4006 return path; 4007} 4008 4009// This code is a copy of JDK's sysSetLength 4010// from src/windows/hpi/src/sys_api_md.c 4011 4012int os::ftruncate(int fd, jlong length) { 4013 HANDLE h = (HANDLE)::_get_osfhandle(fd); 4014 long high = (long)(length >> 32); 4015 DWORD ret; 4016 4017 if (h == (HANDLE)(-1)) { 4018 return -1; 4019 } 4020 4021 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN); 4022 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) { 4023 return -1; 4024 } 4025 4026 if (::SetEndOfFile(h) == FALSE) { 4027 return -1; 4028 } 4029 4030 return 0; 4031} 4032 4033 4034// This code is a copy of JDK's sysSync 4035// from src/windows/hpi/src/sys_api_md.c 4036// except for the legacy workaround for a bug in Win 98 4037 4038int os::fsync(int fd) { 4039 HANDLE handle = (HANDLE)::_get_osfhandle(fd); 4040 4041 if ( (!::FlushFileBuffers(handle)) && 4042 (GetLastError() != ERROR_ACCESS_DENIED) ) { 4043 /* from winerror.h */ 4044 return -1; 4045 } 4046 return 0; 4047} 4048 4049static int nonSeekAvailable(int, long *); 4050static int stdinAvailable(int, long *); 4051 4052#define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR) 4053#define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO) 4054 4055// This code is a copy of JDK's sysAvailable 4056// from src/windows/hpi/src/sys_api_md.c 4057 4058int os::available(int fd, jlong *bytes) { 4059 jlong cur, end; 4060 struct _stati64 stbuf64; 4061 4062 if (::_fstati64(fd, &stbuf64) >= 0) { 4063 int mode = stbuf64.st_mode; 4064 if (S_ISCHR(mode) || S_ISFIFO(mode)) { 4065 int ret; 4066 long lpbytes; 4067 if (fd == 0) { 4068 ret = stdinAvailable(fd, &lpbytes); 4069 } else { 4070 ret = nonSeekAvailable(fd, &lpbytes); 4071 } 4072 (*bytes) = (jlong)(lpbytes); 4073 return ret; 4074 } 4075 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) { 4076 return FALSE; 4077 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) { 4078 return FALSE; 4079 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) { 4080 return FALSE; 4081 } 4082 *bytes = end - cur; 4083 return TRUE; 4084 } else { 4085 return FALSE; 4086 } 4087} 4088 4089// This code is a copy of JDK's nonSeekAvailable 4090// from src/windows/hpi/src/sys_api_md.c 4091 4092static int nonSeekAvailable(int fd, long *pbytes) { 4093 /* This is used for available on non-seekable devices 4094 * (like both named and anonymous pipes, such as pipes 4095 * connected to an exec'd process). 4096 * Standard Input is a special case. 4097 * 4098 */ 4099 HANDLE han; 4100 4101 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) { 4102 return FALSE; 4103 } 4104 4105 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) { 4106 /* PeekNamedPipe fails when at EOF. In that case we 4107 * simply make *pbytes = 0 which is consistent with the 4108 * behavior we get on Solaris when an fd is at EOF. 4109 * The only alternative is to raise an Exception, 4110 * which isn't really warranted. 4111 */ 4112 if (::GetLastError() != ERROR_BROKEN_PIPE) { 4113 return FALSE; 4114 } 4115 *pbytes = 0; 4116 } 4117 return TRUE; 4118} 4119 4120#define MAX_INPUT_EVENTS 2000 4121 4122// This code is a copy of JDK's stdinAvailable 4123// from src/windows/hpi/src/sys_api_md.c 4124 4125static int stdinAvailable(int fd, long *pbytes) { 4126 HANDLE han; 4127 DWORD numEventsRead = 0; /* Number of events read from buffer */ 4128 DWORD numEvents = 0; /* Number of events in buffer */ 4129 DWORD i = 0; /* Loop index */ 4130 DWORD curLength = 0; /* Position marker */ 4131 DWORD actualLength = 0; /* Number of bytes readable */ 4132 BOOL error = FALSE; /* Error holder */ 4133 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */ 4134 4135 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) { 4136 return FALSE; 4137 } 4138 4139 /* Construct an array of input records in the console buffer */ 4140 error = ::GetNumberOfConsoleInputEvents(han, &numEvents); 4141 if (error == 0) { 4142 return nonSeekAvailable(fd, pbytes); 4143 } 4144 4145 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */ 4146 if (numEvents > MAX_INPUT_EVENTS) { 4147 numEvents = MAX_INPUT_EVENTS; 4148 } 4149 4150 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD)); 4151 if (lpBuffer == NULL) { 4152 return FALSE; 4153 } 4154 4155 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead); 4156 if (error == 0) { 4157 os::free(lpBuffer); 4158 return FALSE; 4159 } 4160 4161 /* Examine input records for the number of bytes available */ 4162 for(i=0; i<numEvents; i++) { 4163 if (lpBuffer[i].EventType == KEY_EVENT) { 4164 4165 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *) 4166 &(lpBuffer[i].Event); 4167 if (keyRecord->bKeyDown == TRUE) { 4168 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar); 4169 curLength++; 4170 if (*keyPressed == '\r') { 4171 actualLength = curLength; 4172 } 4173 } 4174 } 4175 } 4176 4177 if(lpBuffer != NULL) { 4178 os::free(lpBuffer); 4179 } 4180 4181 *pbytes = (long) actualLength; 4182 return TRUE; 4183} 4184 4185// Map a block of memory. 4186char* os::map_memory(int fd, const char* file_name, size_t file_offset, 4187 char *addr, size_t bytes, bool read_only, 4188 bool allow_exec) { 4189 HANDLE hFile; 4190 char* base; 4191 4192 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, 4193 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 4194 if (hFile == NULL) { 4195 if (PrintMiscellaneous && Verbose) { 4196 DWORD err = GetLastError(); 4197 tty->print_cr("CreateFile() failed: GetLastError->%ld."); 4198 } 4199 return NULL; 4200 } 4201 4202 if (allow_exec) { 4203 // CreateFileMapping/MapViewOfFileEx can't map executable memory 4204 // unless it comes from a PE image (which the shared archive is not.) 4205 // Even VirtualProtect refuses to give execute access to mapped memory 4206 // that was not previously executable. 4207 // 4208 // Instead, stick the executable region in anonymous memory. Yuck. 4209 // Penalty is that ~4 pages will not be shareable - in the future 4210 // we might consider DLLizing the shared archive with a proper PE 4211 // header so that mapping executable + sharing is possible. 4212 4213 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE, 4214 PAGE_READWRITE); 4215 if (base == NULL) { 4216 if (PrintMiscellaneous && Verbose) { 4217 DWORD err = GetLastError(); 4218 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err); 4219 } 4220 CloseHandle(hFile); 4221 return NULL; 4222 } 4223 4224 DWORD bytes_read; 4225 OVERLAPPED overlapped; 4226 overlapped.Offset = (DWORD)file_offset; 4227 overlapped.OffsetHigh = 0; 4228 overlapped.hEvent = NULL; 4229 // ReadFile guarantees that if the return value is true, the requested 4230 // number of bytes were read before returning. 4231 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0; 4232 if (!res) { 4233 if (PrintMiscellaneous && Verbose) { 4234 DWORD err = GetLastError(); 4235 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err); 4236 } 4237 release_memory(base, bytes); 4238 CloseHandle(hFile); 4239 return NULL; 4240 } 4241 } else { 4242 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0, 4243 NULL /*file_name*/); 4244 if (hMap == NULL) { 4245 if (PrintMiscellaneous && Verbose) { 4246 DWORD err = GetLastError(); 4247 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld."); 4248 } 4249 CloseHandle(hFile); 4250 return NULL; 4251 } 4252 4253 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY; 4254 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset, 4255 (DWORD)bytes, addr); 4256 if (base == NULL) { 4257 if (PrintMiscellaneous && Verbose) { 4258 DWORD err = GetLastError(); 4259 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err); 4260 } 4261 CloseHandle(hMap); 4262 CloseHandle(hFile); 4263 return NULL; 4264 } 4265 4266 if (CloseHandle(hMap) == 0) { 4267 if (PrintMiscellaneous && Verbose) { 4268 DWORD err = GetLastError(); 4269 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err); 4270 } 4271 CloseHandle(hFile); 4272 return base; 4273 } 4274 } 4275 4276 if (allow_exec) { 4277 DWORD old_protect; 4278 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE; 4279 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0; 4280 4281 if (!res) { 4282 if (PrintMiscellaneous && Verbose) { 4283 DWORD err = GetLastError(); 4284 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err); 4285 } 4286 // Don't consider this a hard error, on IA32 even if the 4287 // VirtualProtect fails, we should still be able to execute 4288 CloseHandle(hFile); 4289 return base; 4290 } 4291 } 4292 4293 if (CloseHandle(hFile) == 0) { 4294 if (PrintMiscellaneous && Verbose) { 4295 DWORD err = GetLastError(); 4296 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err); 4297 } 4298 return base; 4299 } 4300 4301 return base; 4302} 4303 4304 4305// Remap a block of memory. 4306char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 4307 char *addr, size_t bytes, bool read_only, 4308 bool allow_exec) { 4309 // This OS does not allow existing memory maps to be remapped so we 4310 // have to unmap the memory before we remap it. 4311 if (!os::unmap_memory(addr, bytes)) { 4312 return NULL; 4313 } 4314 4315 // There is a very small theoretical window between the unmap_memory() 4316 // call above and the map_memory() call below where a thread in native 4317 // code may be able to access an address that is no longer mapped. 4318 4319 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 4320 allow_exec); 4321} 4322 4323 4324// Unmap a block of memory. 4325// Returns true=success, otherwise false. 4326 4327bool os::unmap_memory(char* addr, size_t bytes) { 4328 BOOL result = UnmapViewOfFile(addr); 4329 if (result == 0) { 4330 if (PrintMiscellaneous && Verbose) { 4331 DWORD err = GetLastError(); 4332 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err); 4333 } 4334 return false; 4335 } 4336 return true; 4337} 4338 4339void os::pause() { 4340 char filename[MAX_PATH]; 4341 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 4342 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 4343 } else { 4344 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 4345 } 4346 4347 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 4348 if (fd != -1) { 4349 struct stat buf; 4350 ::close(fd); 4351 while (::stat(filename, &buf) == 0) { 4352 Sleep(100); 4353 } 4354 } else { 4355 jio_fprintf(stderr, 4356 "Could not open pause file '%s', continuing immediately.\n", filename); 4357 } 4358} 4359 4360// An Event wraps a win32 "CreateEvent" kernel handle. 4361// 4362// We have a number of choices regarding "CreateEvent" win32 handle leakage: 4363// 4364// 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle 4365// field, and call CloseHandle() on the win32 event handle. Unpark() would 4366// need to be modified to tolerate finding a NULL (invalid) win32 event handle. 4367// In addition, an unpark() operation might fetch the handle field, but the 4368// event could recycle between the fetch and the SetEvent() operation. 4369// SetEvent() would either fail because the handle was invalid, or inadvertently work, 4370// as the win32 handle value had been recycled. In an ideal world calling SetEvent() 4371// on an stale but recycled handle would be harmless, but in practice this might 4372// confuse other non-Sun code, so it's not a viable approach. 4373// 4374// 2: Once a win32 event handle is associated with an Event, it remains associated 4375// with the Event. The event handle is never closed. This could be construed 4376// as handle leakage, but only up to the maximum # of threads that have been extant 4377// at any one time. This shouldn't be an issue, as windows platforms typically 4378// permit a process to have hundreds of thousands of open handles. 4379// 4380// 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList 4381// and release unused handles. 4382// 4383// 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle. 4384// It's not clear, however, that we wouldn't be trading one type of leak for another. 4385// 4386// 5. Use an RCU-like mechanism (Read-Copy Update). 4387// Or perhaps something similar to Maged Michael's "Hazard pointers". 4388// 4389// We use (2). 4390// 4391// TODO-FIXME: 4392// 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation. 4393// 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks 4394// to recover from (or at least detect) the dreaded Windows 841176 bug. 4395// 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent 4396// into a single win32 CreateEvent() handle. 4397// 4398// _Event transitions in park() 4399// -1 => -1 : illegal 4400// 1 => 0 : pass - return immediately 4401// 0 => -1 : block 4402// 4403// _Event serves as a restricted-range semaphore : 4404// -1 : thread is blocked 4405// 0 : neutral - thread is running or ready 4406// 1 : signaled - thread is running or ready 4407// 4408// Another possible encoding of _Event would be 4409// with explicit "PARKED" and "SIGNALED" bits. 4410 4411int os::PlatformEvent::park (jlong Millis) { 4412 guarantee (_ParkHandle != NULL , "Invariant") ; 4413 guarantee (Millis > 0 , "Invariant") ; 4414 int v ; 4415 4416 // CONSIDER: defer assigning a CreateEvent() handle to the Event until 4417 // the initial park() operation. 4418 4419 for (;;) { 4420 v = _Event ; 4421 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4422 } 4423 guarantee ((v == 0) || (v == 1), "invariant") ; 4424 if (v != 0) return OS_OK ; 4425 4426 // Do this the hard way by blocking ... 4427 // TODO: consider a brief spin here, gated on the success of recent 4428 // spin attempts by this thread. 4429 // 4430 // We decompose long timeouts into series of shorter timed waits. 4431 // Evidently large timo values passed in WaitForSingleObject() are problematic on some 4432 // versions of Windows. See EventWait() for details. This may be superstition. Or not. 4433 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time 4434 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from 4435 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend 4436 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv == 4437 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate 4438 // for the already waited time. This policy does not admit any new outcomes. 4439 // In the future, however, we might want to track the accumulated wait time and 4440 // adjust Millis accordingly if we encounter a spurious wakeup. 4441 4442 const int MAXTIMEOUT = 0x10000000 ; 4443 DWORD rv = WAIT_TIMEOUT ; 4444 while (_Event < 0 && Millis > 0) { 4445 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT) 4446 if (Millis > MAXTIMEOUT) { 4447 prd = MAXTIMEOUT ; 4448 } 4449 rv = ::WaitForSingleObject (_ParkHandle, prd) ; 4450 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ; 4451 if (rv == WAIT_TIMEOUT) { 4452 Millis -= prd ; 4453 } 4454 } 4455 v = _Event ; 4456 _Event = 0 ; 4457 OrderAccess::fence() ; 4458 // If we encounter a nearly simultanous timeout expiry and unpark() 4459 // we return OS_OK indicating we awoke via unpark(). 4460 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however. 4461 return (v >= 0) ? OS_OK : OS_TIMEOUT ; 4462} 4463 4464void os::PlatformEvent::park () { 4465 guarantee (_ParkHandle != NULL, "Invariant") ; 4466 // Invariant: Only the thread associated with the Event/PlatformEvent 4467 // may call park(). 4468 int v ; 4469 for (;;) { 4470 v = _Event ; 4471 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4472 } 4473 guarantee ((v == 0) || (v == 1), "invariant") ; 4474 if (v != 0) return ; 4475 4476 // Do this the hard way by blocking ... 4477 // TODO: consider a brief spin here, gated on the success of recent 4478 // spin attempts by this thread. 4479 while (_Event < 0) { 4480 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ; 4481 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ; 4482 } 4483 4484 // Usually we'll find _Event == 0 at this point, but as 4485 // an optional optimization we clear it, just in case can 4486 // multiple unpark() operations drove _Event up to 1. 4487 _Event = 0 ; 4488 OrderAccess::fence() ; 4489 guarantee (_Event >= 0, "invariant") ; 4490} 4491 4492void os::PlatformEvent::unpark() { 4493 guarantee (_ParkHandle != NULL, "Invariant") ; 4494 int v ; 4495 for (;;) { 4496 v = _Event ; // Increment _Event if it's < 1. 4497 if (v > 0) { 4498 // If it's already signaled just return. 4499 // The LD of _Event could have reordered or be satisfied 4500 // by a read-aside from this processor's write buffer. 4501 // To avoid problems execute a barrier and then 4502 // ratify the value. A degenerate CAS() would also work. 4503 // Viz., CAS (v+0, &_Event, v) == v). 4504 OrderAccess::fence() ; 4505 if (_Event == v) return ; 4506 continue ; 4507 } 4508 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 4509 } 4510 if (v < 0) { 4511 ::SetEvent (_ParkHandle) ; 4512 } 4513} 4514 4515 4516// JSR166 4517// ------------------------------------------------------- 4518 4519/* 4520 * The Windows implementation of Park is very straightforward: Basic 4521 * operations on Win32 Events turn out to have the right semantics to 4522 * use them directly. We opportunistically resuse the event inherited 4523 * from Monitor. 4524 */ 4525 4526 4527void Parker::park(bool isAbsolute, jlong time) { 4528 guarantee (_ParkEvent != NULL, "invariant") ; 4529 // First, demultiplex/decode time arguments 4530 if (time < 0) { // don't wait 4531 return; 4532 } 4533 else if (time == 0 && !isAbsolute) { 4534 time = INFINITE; 4535 } 4536 else if (isAbsolute) { 4537 time -= os::javaTimeMillis(); // convert to relative time 4538 if (time <= 0) // already elapsed 4539 return; 4540 } 4541 else { // relative 4542 time /= 1000000; // Must coarsen from nanos to millis 4543 if (time == 0) // Wait for the minimal time unit if zero 4544 time = 1; 4545 } 4546 4547 JavaThread* thread = (JavaThread*)(Thread::current()); 4548 assert(thread->is_Java_thread(), "Must be JavaThread"); 4549 JavaThread *jt = (JavaThread *)thread; 4550 4551 // Don't wait if interrupted or already triggered 4552 if (Thread::is_interrupted(thread, false) || 4553 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) { 4554 ResetEvent(_ParkEvent); 4555 return; 4556 } 4557 else { 4558 ThreadBlockInVM tbivm(jt); 4559 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 4560 jt->set_suspend_equivalent(); 4561 4562 WaitForSingleObject(_ParkEvent, time); 4563 ResetEvent(_ParkEvent); 4564 4565 // If externally suspended while waiting, re-suspend 4566 if (jt->handle_special_suspend_equivalent_condition()) { 4567 jt->java_suspend_self(); 4568 } 4569 } 4570} 4571 4572void Parker::unpark() { 4573 guarantee (_ParkEvent != NULL, "invariant") ; 4574 SetEvent(_ParkEvent); 4575} 4576 4577// Run the specified command in a separate process. Return its exit value, 4578// or -1 on failure (e.g. can't create a new process). 4579int os::fork_and_exec(char* cmd) { 4580 STARTUPINFO si; 4581 PROCESS_INFORMATION pi; 4582 4583 memset(&si, 0, sizeof(si)); 4584 si.cb = sizeof(si); 4585 memset(&pi, 0, sizeof(pi)); 4586 BOOL rslt = CreateProcess(NULL, // executable name - use command line 4587 cmd, // command line 4588 NULL, // process security attribute 4589 NULL, // thread security attribute 4590 TRUE, // inherits system handles 4591 0, // no creation flags 4592 NULL, // use parent's environment block 4593 NULL, // use parent's starting directory 4594 &si, // (in) startup information 4595 &pi); // (out) process information 4596 4597 if (rslt) { 4598 // Wait until child process exits. 4599 WaitForSingleObject(pi.hProcess, INFINITE); 4600 4601 DWORD exit_code; 4602 GetExitCodeProcess(pi.hProcess, &exit_code); 4603 4604 // Close process and thread handles. 4605 CloseHandle(pi.hProcess); 4606 CloseHandle(pi.hThread); 4607 4608 return (int)exit_code; 4609 } else { 4610 return -1; 4611 } 4612} 4613 4614//-------------------------------------------------------------------------------------------------- 4615// Non-product code 4616 4617static int mallocDebugIntervalCounter = 0; 4618static int mallocDebugCounter = 0; 4619bool os::check_heap(bool force) { 4620 if (++mallocDebugCounter < MallocVerifyStart && !force) return true; 4621 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) { 4622 // Note: HeapValidate executes two hardware breakpoints when it finds something 4623 // wrong; at these points, eax contains the address of the offending block (I think). 4624 // To get to the exlicit error message(s) below, just continue twice. 4625 HANDLE heap = GetProcessHeap(); 4626 { HeapLock(heap); 4627 PROCESS_HEAP_ENTRY phe; 4628 phe.lpData = NULL; 4629 while (HeapWalk(heap, &phe) != 0) { 4630 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) && 4631 !HeapValidate(heap, 0, phe.lpData)) { 4632 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter); 4633 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData); 4634 fatal("corrupted C heap"); 4635 } 4636 } 4637 int err = GetLastError(); 4638 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) { 4639 fatal(err_msg("heap walk aborted with error %d", err)); 4640 } 4641 HeapUnlock(heap); 4642 } 4643 mallocDebugIntervalCounter = 0; 4644 } 4645 return true; 4646} 4647 4648 4649bool os::find(address addr, outputStream* st) { 4650 // Nothing yet 4651 return false; 4652} 4653 4654LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) { 4655 DWORD exception_code = e->ExceptionRecord->ExceptionCode; 4656 4657 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) { 4658 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow(); 4659 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord; 4660 address addr = (address) exceptionRecord->ExceptionInformation[1]; 4661 4662 if (os::is_memory_serialize_page(thread, addr)) 4663 return EXCEPTION_CONTINUE_EXECUTION; 4664 } 4665 4666 return EXCEPTION_CONTINUE_SEARCH; 4667} 4668 4669static int getLastErrorString(char *buf, size_t len) 4670{ 4671 long errval; 4672 4673 if ((errval = GetLastError()) != 0) 4674 { 4675 /* DOS error */ 4676 size_t n = (size_t)FormatMessage( 4677 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 4678 NULL, 4679 errval, 4680 0, 4681 buf, 4682 (DWORD)len, 4683 NULL); 4684 if (n > 3) { 4685 /* Drop final '.', CR, LF */ 4686 if (buf[n - 1] == '\n') n--; 4687 if (buf[n - 1] == '\r') n--; 4688 if (buf[n - 1] == '.') n--; 4689 buf[n] = '\0'; 4690 } 4691 return (int)n; 4692 } 4693 4694 if (errno != 0) 4695 { 4696 /* C runtime error that has no corresponding DOS error code */ 4697 const char *s = strerror(errno); 4698 size_t n = strlen(s); 4699 if (n >= len) n = len - 1; 4700 strncpy(buf, s, n); 4701 buf[n] = '\0'; 4702 return (int)n; 4703 } 4704 return 0; 4705} 4706 4707 4708// We don't build a headless jre for Windows 4709bool os::is_headless_jre() { return false; } 4710 4711// OS_SocketInterface 4712// Not used on Windows 4713 4714// OS_SocketInterface 4715typedef struct hostent * (PASCAL FAR *ws2_ifn_ptr_t)(...); 4716ws2_ifn_ptr_t *get_host_by_name_fn = NULL; 4717 4718typedef CRITICAL_SECTION mutex_t; 4719#define mutexInit(m) InitializeCriticalSection(m) 4720#define mutexDestroy(m) DeleteCriticalSection(m) 4721#define mutexLock(m) EnterCriticalSection(m) 4722#define mutexUnlock(m) LeaveCriticalSection(m) 4723 4724static bool sockfnptrs_initialized = FALSE; 4725static mutex_t sockFnTableMutex; 4726 4727/* is Winsock2 loaded? better to be explicit than to rely on sockfnptrs */ 4728static bool winsock2Available = FALSE; 4729 4730 4731static void initSockFnTable() { 4732 int (PASCAL FAR* WSAStartupPtr)(WORD, LPWSADATA); 4733 WSADATA wsadata; 4734 4735 ::mutexInit(&sockFnTableMutex); 4736 ::mutexLock(&sockFnTableMutex); 4737 4738 if (sockfnptrs_initialized == FALSE) { 4739 HMODULE hWinsock; 4740 4741 /* try to load Winsock2, and if that fails, load Winsock */ 4742 hWinsock = ::LoadLibrary("ws2_32.dll"); 4743 4744 if (hWinsock == NULL) { 4745 jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n", 4746 ::GetLastError()); 4747 return; 4748 } 4749 4750 /* If we loaded a DLL, then we might as well initialize it. */ 4751 WSAStartupPtr = (int (PASCAL FAR *)(WORD, LPWSADATA)) 4752 ::GetProcAddress(hWinsock, "WSAStartup"); 4753 4754 if (WSAStartupPtr(MAKEWORD(1,1), &wsadata) != 0) { 4755 jio_fprintf(stderr, "Could not initialize Winsock\n"); 4756 } 4757 4758 get_host_by_name_fn 4759 = (ws2_ifn_ptr_t*) GetProcAddress(hWinsock, "gethostbyname"); 4760 } 4761 4762 assert(get_host_by_name_fn != NULL, 4763 "gethostbyname function not found"); 4764 sockfnptrs_initialized = TRUE; 4765 ::mutexUnlock(&sockFnTableMutex); 4766} 4767 4768struct hostent* os::get_host_by_name(char* name) { 4769 if (!sockfnptrs_initialized) { 4770 initSockFnTable(); 4771 } 4772 4773 assert(sockfnptrs_initialized == TRUE && get_host_by_name_fn != NULL, 4774 "sockfnptrs is not initialized or pointer to gethostbyname function is NULL"); 4775 return (*get_host_by_name_fn)(name); 4776} 4777 4778 4779int os::socket_close(int fd) { 4780 ShouldNotReachHere(); 4781 return 0; 4782} 4783 4784int os::socket_available(int fd, jint *pbytes) { 4785 ShouldNotReachHere(); 4786 return 0; 4787} 4788 4789int os::socket(int domain, int type, int protocol) { 4790 ShouldNotReachHere(); 4791 return 0; 4792} 4793 4794int os::listen(int fd, int count) { 4795 ShouldNotReachHere(); 4796 return 0; 4797} 4798 4799int os::connect(int fd, struct sockaddr *him, int len) { 4800 ShouldNotReachHere(); 4801 return 0; 4802} 4803 4804int os::accept(int fd, struct sockaddr *him, int *len) { 4805 ShouldNotReachHere(); 4806 return 0; 4807} 4808 4809int os::sendto(int fd, char *buf, int len, int flags, 4810 struct sockaddr *to, int tolen) { 4811 ShouldNotReachHere(); 4812 return 0; 4813} 4814 4815int os::recvfrom(int fd, char *buf, int nBytes, int flags, 4816 sockaddr *from, int *fromlen) { 4817 ShouldNotReachHere(); 4818 return 0; 4819} 4820 4821int os::recv(int fd, char *buf, int nBytes, int flags) { 4822 ShouldNotReachHere(); 4823 return 0; 4824} 4825 4826int os::send(int fd, char *buf, int nBytes, int flags) { 4827 ShouldNotReachHere(); 4828 return 0; 4829} 4830 4831int os::raw_send(int fd, char *buf, int nBytes, int flags) { 4832 ShouldNotReachHere(); 4833 return 0; 4834} 4835 4836int os::timeout(int fd, long timeout) { 4837 ShouldNotReachHere(); 4838 return 0; 4839} 4840 4841int os::get_host_name(char* name, int namelen) { 4842 ShouldNotReachHere(); 4843 return 0; 4844} 4845 4846int os::socket_shutdown(int fd, int howto) { 4847 ShouldNotReachHere(); 4848 return 0; 4849} 4850 4851int os::bind(int fd, struct sockaddr *him, int len) { 4852 ShouldNotReachHere(); 4853 return 0; 4854} 4855 4856int os::get_sock_name(int fd, struct sockaddr *him, int *len) { 4857 ShouldNotReachHere(); 4858 return 0; 4859} 4860 4861int os::get_sock_opt(int fd, int level, int optname, 4862 char *optval, int* optlen) { 4863 ShouldNotReachHere(); 4864 return 0; 4865} 4866 4867int os::set_sock_opt(int fd, int level, int optname, 4868 const char *optval, int optlen) { 4869 ShouldNotReachHere(); 4870 return 0; 4871} 4872