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