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