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