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