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)) { 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 // Container for NUMA node list info 2618 class NUMANodeListHolder { 2619 private: 2620 int *_numa_used_node_list; // allocated below 2621 int _numa_used_node_count; 2622 2623 void free_node_list() { 2624 if (_numa_used_node_list != NULL) { 2625 FREE_C_HEAP_ARRAY(int, _numa_used_node_list); 2626 } 2627 } 2628 2629 public: 2630 NUMANodeListHolder() { 2631 _numa_used_node_count = 0; 2632 _numa_used_node_list = NULL; 2633 // do rest of initialization in build routine (after function pointers are set up) 2634 } 2635 2636 ~NUMANodeListHolder() { 2637 free_node_list(); 2638 } 2639 2640 bool build() { 2641 DWORD_PTR proc_aff_mask; 2642 DWORD_PTR sys_aff_mask; 2643 if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false; 2644 ULONG highest_node_number; 2645 if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false; 2646 free_node_list(); 2647 _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1); 2648 for (unsigned int i = 0; i <= highest_node_number; i++) { 2649 ULONGLONG proc_mask_numa_node; 2650 if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false; 2651 if ((proc_aff_mask & proc_mask_numa_node)!=0) { 2652 _numa_used_node_list[_numa_used_node_count++] = i; 2653 } 2654 } 2655 return (_numa_used_node_count > 1); 2656 } 2657 2658 int get_count() {return _numa_used_node_count;} 2659 int get_node_list_entry(int n) { 2660 // for indexes out of range, returns -1 2661 return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1); 2662 } 2663 2664 } numa_node_list_holder; 2665 2666 2667 2668 static size_t _large_page_size = 0; 2669 2670 static bool resolve_functions_for_large_page_init() { 2671 return os::Kernel32Dll::GetLargePageMinimumAvailable() && 2672 os::Advapi32Dll::AdvapiAvailable(); 2673 } 2674 2675 static bool request_lock_memory_privilege() { 2676 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, 2677 os::current_process_id()); 2678 2679 LUID luid; 2680 if (_hProcess != NULL && 2681 os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) && 2682 os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) { 2683 2684 TOKEN_PRIVILEGES tp; 2685 tp.PrivilegeCount = 1; 2686 tp.Privileges[0].Luid = luid; 2687 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 2688 2689 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the 2690 // privilege. Check GetLastError() too. See MSDN document. 2691 if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) && 2692 (GetLastError() == ERROR_SUCCESS)) { 2693 return true; 2694 } 2695 } 2696 2697 return false; 2698 } 2699 2700 static void cleanup_after_large_page_init() { 2701 if (_hProcess) CloseHandle(_hProcess); 2702 _hProcess = NULL; 2703 if (_hToken) CloseHandle(_hToken); 2704 _hToken = NULL; 2705 } 2706 2707 static bool numa_interleaving_init() { 2708 bool success = false; 2709 bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving); 2710 2711 // print a warning if UseNUMAInterleaving flag is specified on command line 2712 bool warn_on_failure = use_numa_interleaving_specified; 2713 # define WARN(msg) if (warn_on_failure) { warning(msg); } 2714 2715 // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages) 2716 size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity(); 2717 NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity); 2718 2719 if (os::Kernel32Dll::NumaCallsAvailable()) { 2720 if (numa_node_list_holder.build()) { 2721 if (PrintMiscellaneous && Verbose) { 2722 tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count()); 2723 for (int i = 0; i < numa_node_list_holder.get_count(); i++) { 2724 tty->print("%d ", numa_node_list_holder.get_node_list_entry(i)); 2725 } 2726 tty->print("\n"); 2727 } 2728 success = true; 2729 } else { 2730 WARN("Process does not cover multiple NUMA nodes."); 2731 } 2732 } else { 2733 WARN("NUMA Interleaving is not supported by the operating system."); 2734 } 2735 if (!success) { 2736 if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag."); 2737 } 2738 return success; 2739 #undef WARN 2740 } 2741 2742 // this routine is used whenever we need to reserve a contiguous VA range 2743 // but we need to make separate VirtualAlloc calls for each piece of the range 2744 // Reasons for doing this: 2745 // * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise) 2746 // * UseNUMAInterleaving requires a separate node for each piece 2747 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot, 2748 bool should_inject_error=false) { 2749 char * p_buf; 2750 // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size 2751 size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity(); 2752 size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size; 2753 2754 // first reserve enough address space in advance since we want to be 2755 // able to break a single contiguous virtual address range into multiple 2756 // large page commits but WS2003 does not allow reserving large page space 2757 // so we just use 4K pages for reserve, this gives us a legal contiguous 2758 // address space. then we will deallocate that reservation, and re alloc 2759 // using large pages 2760 const size_t size_of_reserve = bytes + chunk_size; 2761 if (bytes > size_of_reserve) { 2762 // Overflowed. 2763 return NULL; 2764 } 2765 p_buf = (char *) VirtualAlloc(addr, 2766 size_of_reserve, // size of Reserve 2767 MEM_RESERVE, 2768 PAGE_READWRITE); 2769 // If reservation failed, return NULL 2770 if (p_buf == NULL) return NULL; 2771 2772 os::release_memory(p_buf, bytes + chunk_size); 2773 2774 // we still need to round up to a page boundary (in case we are using large pages) 2775 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size) 2776 // instead we handle this in the bytes_to_rq computation below 2777 p_buf = (char *) align_size_up((size_t)p_buf, page_size); 2778 2779 // now go through and allocate one chunk at a time until all bytes are 2780 // allocated 2781 size_t bytes_remaining = bytes; 2782 // An overflow of align_size_up() would have been caught above 2783 // in the calculation of size_of_reserve. 2784 char * next_alloc_addr = p_buf; 2785 HANDLE hProc = GetCurrentProcess(); 2786 2787 #ifdef ASSERT 2788 // Variable for the failure injection 2789 long ran_num = os::random(); 2790 size_t fail_after = ran_num % bytes; 2791 #endif 2792 2793 int count=0; 2794 while (bytes_remaining) { 2795 // select bytes_to_rq to get to the next chunk_size boundary 2796 2797 size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size)); 2798 // Note allocate and commit 2799 char * p_new; 2800 2801 #ifdef ASSERT 2802 bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after); 2803 #else 2804 const bool inject_error_now = false; 2805 #endif 2806 2807 if (inject_error_now) { 2808 p_new = NULL; 2809 } else { 2810 if (!UseNUMAInterleaving) { 2811 p_new = (char *) VirtualAlloc(next_alloc_addr, 2812 bytes_to_rq, 2813 flags, 2814 prot); 2815 } else { 2816 // get the next node to use from the used_node_list 2817 assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected"); 2818 DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count()); 2819 p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc, 2820 next_alloc_addr, 2821 bytes_to_rq, 2822 flags, 2823 prot, 2824 node); 2825 } 2826 } 2827 2828 if (p_new == NULL) { 2829 // Free any allocated pages 2830 if (next_alloc_addr > p_buf) { 2831 // Some memory was committed so release it. 2832 size_t bytes_to_release = bytes - bytes_remaining; 2833 os::release_memory(p_buf, bytes_to_release); 2834 } 2835 #ifdef ASSERT 2836 if (should_inject_error) { 2837 if (TracePageSizes && Verbose) { 2838 tty->print_cr("Reserving pages individually failed."); 2839 } 2840 } 2841 #endif 2842 return NULL; 2843 } 2844 bytes_remaining -= bytes_to_rq; 2845 next_alloc_addr += bytes_to_rq; 2846 count++; 2847 } 2848 // made it this far, success 2849 return p_buf; 2850 } 2851 2852 2853 2854 void os::large_page_init() { 2855 if (!UseLargePages) return; 2856 2857 // print a warning if any large page related flag is specified on command line 2858 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) || 2859 !FLAG_IS_DEFAULT(LargePageSizeInBytes); 2860 bool success = false; 2861 2862 # define WARN(msg) if (warn_on_failure) { warning(msg); } 2863 if (resolve_functions_for_large_page_init()) { 2864 if (request_lock_memory_privilege()) { 2865 size_t s = os::Kernel32Dll::GetLargePageMinimum(); 2866 if (s) { 2867 #if defined(IA32) || defined(AMD64) 2868 if (s > 4*M || LargePageSizeInBytes > 4*M) { 2869 WARN("JVM cannot use large pages bigger than 4mb."); 2870 } else { 2871 #endif 2872 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) { 2873 _large_page_size = LargePageSizeInBytes; 2874 } else { 2875 _large_page_size = s; 2876 } 2877 success = true; 2878 #if defined(IA32) || defined(AMD64) 2879 } 2880 #endif 2881 } else { 2882 WARN("Large page is not supported by the processor."); 2883 } 2884 } else { 2885 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory."); 2886 } 2887 } else { 2888 WARN("Large page is not supported by the operating system."); 2889 } 2890 #undef WARN 2891 2892 const size_t default_page_size = (size_t) vm_page_size(); 2893 if (success && _large_page_size > default_page_size) { 2894 _page_sizes[0] = _large_page_size; 2895 _page_sizes[1] = default_page_size; 2896 _page_sizes[2] = 0; 2897 } 2898 2899 cleanup_after_large_page_init(); 2900 UseLargePages = success; 2901 } 2902 2903 // On win32, one cannot release just a part of reserved memory, it's an 2904 // all or nothing deal. When we split a reservation, we must break the 2905 // reservation into two reservations. 2906 void os::split_reserved_memory(char *base, size_t size, size_t split, 2907 bool realloc) { 2908 if (size > 0) { 2909 release_memory(base, size); 2910 if (realloc) { 2911 reserve_memory(split, base); 2912 } 2913 if (size != split) { 2914 reserve_memory(size - split, base + split); 2915 } 2916 } 2917 } 2918 2919 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 2920 assert((size_t)addr % os::vm_allocation_granularity() == 0, 2921 "reserve alignment"); 2922 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size"); 2923 char* res; 2924 // note that if UseLargePages is on, all the areas that require interleaving 2925 // will go thru reserve_memory_special rather than thru here. 2926 bool use_individual = (UseNUMAInterleaving && !UseLargePages); 2927 if (!use_individual) { 2928 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE); 2929 } else { 2930 elapsedTimer reserveTimer; 2931 if( Verbose && PrintMiscellaneous ) reserveTimer.start(); 2932 // in numa interleaving, we have to allocate pages individually 2933 // (well really chunks of NUMAInterleaveGranularity size) 2934 res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE); 2935 if (res == NULL) { 2936 warning("NUMA page allocation failed"); 2937 } 2938 if( Verbose && PrintMiscellaneous ) { 2939 reserveTimer.stop(); 2940 tty->print_cr("reserve_memory of %Ix bytes took %ld ms (%ld ticks)", bytes, 2941 reserveTimer.milliseconds(), reserveTimer.ticks()); 2942 } 2943 } 2944 assert(res == NULL || addr == NULL || addr == res, 2945 "Unexpected address from reserve."); 2946 2947 return res; 2948 } 2949 2950 // Reserve memory at an arbitrary address, only if that area is 2951 // available (and not reserved for something else). 2952 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) { 2953 // Windows os::reserve_memory() fails of the requested address range is 2954 // not avilable. 2955 return reserve_memory(bytes, requested_addr); 2956 } 2957 2958 size_t os::large_page_size() { 2959 return _large_page_size; 2960 } 2961 2962 bool os::can_commit_large_page_memory() { 2963 // Windows only uses large page memory when the entire region is reserved 2964 // and committed in a single VirtualAlloc() call. This may change in the 2965 // future, but with Windows 2003 it's not possible to commit on demand. 2966 return false; 2967 } 2968 2969 bool os::can_execute_large_page_memory() { 2970 return true; 2971 } 2972 2973 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) { 2974 2975 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE; 2976 const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 2977 2978 // with large pages, there are two cases where we need to use Individual Allocation 2979 // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003) 2980 // 2) NUMA Interleaving is enabled, in which case we use a different node for each page 2981 if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) { 2982 if (TracePageSizes && Verbose) { 2983 tty->print_cr("Reserving large pages individually."); 2984 } 2985 char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError); 2986 if (p_buf == NULL) { 2987 // give an appropriate warning message 2988 if (UseNUMAInterleaving) { 2989 warning("NUMA large page allocation failed, UseLargePages flag ignored"); 2990 } 2991 if (UseLargePagesIndividualAllocation) { 2992 warning("Individually allocated large pages failed, " 2993 "use -XX:-UseLargePagesIndividualAllocation to turn off"); 2994 } 2995 return NULL; 2996 } 2997 2998 return p_buf; 2999 3000 } else { 3001 // normal policy just allocate it all at once 3002 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES; 3003 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot); 3004 return res; 3005 } 3006 } 3007 3008 bool os::release_memory_special(char* base, size_t bytes) { 3009 return release_memory(base, bytes); 3010 } 3011 3012 void os::print_statistics() { 3013 } 3014 3015 bool os::commit_memory(char* addr, size_t bytes, bool exec) { 3016 if (bytes == 0) { 3017 // Don't bother the OS with noops. 3018 return true; 3019 } 3020 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries"); 3021 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks"); 3022 // Don't attempt to print anything if the OS call fails. We're 3023 // probably low on resources, so the print itself may cause crashes. 3024 3025 // unless we have NUMAInterleaving enabled, the range of a commit 3026 // is always within a reserve covered by a single VirtualAlloc 3027 // in that case we can just do a single commit for the requested size 3028 if (!UseNUMAInterleaving) { 3029 if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) return false; 3030 if (exec) { 3031 DWORD oldprot; 3032 // Windows doc says to use VirtualProtect to get execute permissions 3033 if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) return false; 3034 } 3035 return true; 3036 } else { 3037 3038 // when NUMAInterleaving is enabled, the commit might cover a range that 3039 // came from multiple VirtualAlloc reserves (using allocate_pages_individually). 3040 // VirtualQuery can help us determine that. The RegionSize that VirtualQuery 3041 // returns represents the number of bytes that can be committed in one step. 3042 size_t bytes_remaining = bytes; 3043 char * next_alloc_addr = addr; 3044 while (bytes_remaining > 0) { 3045 MEMORY_BASIC_INFORMATION alloc_info; 3046 VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info)); 3047 size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize); 3048 if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT, PAGE_READWRITE) == NULL) 3049 return false; 3050 if (exec) { 3051 DWORD oldprot; 3052 if (!VirtualProtect(next_alloc_addr, bytes_to_rq, PAGE_EXECUTE_READWRITE, &oldprot)) 3053 return false; 3054 } 3055 bytes_remaining -= bytes_to_rq; 3056 next_alloc_addr += bytes_to_rq; 3057 } 3058 } 3059 // if we made it this far, return true 3060 return true; 3061 } 3062 3063 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 3064 bool exec) { 3065 return commit_memory(addr, size, exec); 3066 } 3067 3068 bool os::uncommit_memory(char* addr, size_t bytes) { 3069 if (bytes == 0) { 3070 // Don't bother the OS with noops. 3071 return true; 3072 } 3073 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries"); 3074 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks"); 3075 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0; 3076 } 3077 3078 bool os::release_memory(char* addr, size_t bytes) { 3079 return VirtualFree(addr, 0, MEM_RELEASE) != 0; 3080 } 3081 3082 bool os::create_stack_guard_pages(char* addr, size_t size) { 3083 return os::commit_memory(addr, size); 3084 } 3085 3086 bool os::remove_stack_guard_pages(char* addr, size_t size) { 3087 return os::uncommit_memory(addr, size); 3088 } 3089 3090 // Set protections specified 3091 bool os::protect_memory(char* addr, size_t bytes, ProtType prot, 3092 bool is_committed) { 3093 unsigned int p = 0; 3094 switch (prot) { 3095 case MEM_PROT_NONE: p = PAGE_NOACCESS; break; 3096 case MEM_PROT_READ: p = PAGE_READONLY; break; 3097 case MEM_PROT_RW: p = PAGE_READWRITE; break; 3098 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break; 3099 default: 3100 ShouldNotReachHere(); 3101 } 3102 3103 DWORD old_status; 3104 3105 // Strange enough, but on Win32 one can change protection only for committed 3106 // memory, not a big deal anyway, as bytes less or equal than 64K 3107 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) { 3108 fatal("cannot commit protection page"); 3109 } 3110 // One cannot use os::guard_memory() here, as on Win32 guard page 3111 // have different (one-shot) semantics, from MSDN on PAGE_GUARD: 3112 // 3113 // Pages in the region become guard pages. Any attempt to access a guard page 3114 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off 3115 // the guard page status. Guard pages thus act as a one-time access alarm. 3116 return VirtualProtect(addr, bytes, p, &old_status) != 0; 3117 } 3118 3119 bool os::guard_memory(char* addr, size_t bytes) { 3120 DWORD old_status; 3121 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0; 3122 } 3123 3124 bool os::unguard_memory(char* addr, size_t bytes) { 3125 DWORD old_status; 3126 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0; 3127 } 3128 3129 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { } 3130 void os::free_memory(char *addr, size_t bytes) { } 3131 void os::numa_make_global(char *addr, size_t bytes) { } 3132 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { } 3133 bool os::numa_topology_changed() { return false; } 3134 size_t os::numa_get_groups_num() { return MAX2(numa_node_list_holder.get_count(), 1); } 3135 int os::numa_get_group_id() { return 0; } 3136 size_t os::numa_get_leaf_groups(int *ids, size_t size) { 3137 if (numa_node_list_holder.get_count() == 0 && size > 0) { 3138 // Provide an answer for UMA systems 3139 ids[0] = 0; 3140 return 1; 3141 } else { 3142 // check for size bigger than actual groups_num 3143 size = MIN2(size, numa_get_groups_num()); 3144 for (int i = 0; i < (int)size; i++) { 3145 ids[i] = numa_node_list_holder.get_node_list_entry(i); 3146 } 3147 return size; 3148 } 3149 } 3150 3151 bool os::get_page_info(char *start, page_info* info) { 3152 return false; 3153 } 3154 3155 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) { 3156 return end; 3157 } 3158 3159 char* os::non_memory_address_word() { 3160 // Must never look like an address returned by reserve_memory, 3161 // even in its subfields (as defined by the CPU immediate fields, 3162 // if the CPU splits constants across multiple instructions). 3163 return (char*)-1; 3164 } 3165 3166 #define MAX_ERROR_COUNT 100 3167 #define SYS_THREAD_ERROR 0xffffffffUL 3168 3169 void os::pd_start_thread(Thread* thread) { 3170 DWORD ret = ResumeThread(thread->osthread()->thread_handle()); 3171 // Returns previous suspend state: 3172 // 0: Thread was not suspended 3173 // 1: Thread is running now 3174 // >1: Thread is still suspended. 3175 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back 3176 } 3177 3178 class HighResolutionInterval { 3179 // The default timer resolution seems to be 10 milliseconds. 3180 // (Where is this written down?) 3181 // If someone wants to sleep for only a fraction of the default, 3182 // then we set the timer resolution down to 1 millisecond for 3183 // the duration of their interval. 3184 // We carefully set the resolution back, since otherwise we 3185 // seem to incur an overhead (3%?) that we don't need. 3186 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time. 3187 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod(). 3188 // Alternatively, we could compute the relative error (503/500 = .6%) and only use 3189 // timeBeginPeriod() if the relative error exceeded some threshold. 3190 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and 3191 // to decreased efficiency related to increased timer "tick" rates. We want to minimize 3192 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high 3193 // resolution timers running. 3194 private: 3195 jlong resolution; 3196 public: 3197 HighResolutionInterval(jlong ms) { 3198 resolution = ms % 10L; 3199 if (resolution != 0) { 3200 MMRESULT result = timeBeginPeriod(1L); 3201 } 3202 } 3203 ~HighResolutionInterval() { 3204 if (resolution != 0) { 3205 MMRESULT result = timeEndPeriod(1L); 3206 } 3207 resolution = 0L; 3208 } 3209 }; 3210 3211 int os::sleep(Thread* thread, jlong ms, bool interruptable) { 3212 jlong limit = (jlong) MAXDWORD; 3213 3214 while(ms > limit) { 3215 int res; 3216 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) 3217 return res; 3218 ms -= limit; 3219 } 3220 3221 assert(thread == Thread::current(), "thread consistency check"); 3222 OSThread* osthread = thread->osthread(); 3223 OSThreadWaitState osts(osthread, false /* not Object.wait() */); 3224 int result; 3225 if (interruptable) { 3226 assert(thread->is_Java_thread(), "must be java thread"); 3227 JavaThread *jt = (JavaThread *) thread; 3228 ThreadBlockInVM tbivm(jt); 3229 3230 jt->set_suspend_equivalent(); 3231 // cleared by handle_special_suspend_equivalent_condition() or 3232 // java_suspend_self() via check_and_wait_while_suspended() 3233 3234 HANDLE events[1]; 3235 events[0] = osthread->interrupt_event(); 3236 HighResolutionInterval *phri=NULL; 3237 if(!ForceTimeHighResolution) 3238 phri = new HighResolutionInterval( ms ); 3239 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) { 3240 result = OS_TIMEOUT; 3241 } else { 3242 ResetEvent(osthread->interrupt_event()); 3243 osthread->set_interrupted(false); 3244 result = OS_INTRPT; 3245 } 3246 delete phri; //if it is NULL, harmless 3247 3248 // were we externally suspended while we were waiting? 3249 jt->check_and_wait_while_suspended(); 3250 } else { 3251 assert(!thread->is_Java_thread(), "must not be java thread"); 3252 Sleep((long) ms); 3253 result = OS_TIMEOUT; 3254 } 3255 return result; 3256 } 3257 3258 // Sleep forever; naked call to OS-specific sleep; use with CAUTION 3259 void os::infinite_sleep() { 3260 while (true) { // sleep forever ... 3261 Sleep(100000); // ... 100 seconds at a time 3262 } 3263 } 3264 3265 typedef BOOL (WINAPI * STTSignature)(void) ; 3266 3267 os::YieldResult os::NakedYield() { 3268 // Use either SwitchToThread() or Sleep(0) 3269 // Consider passing back the return value from SwitchToThread(). 3270 if (os::Kernel32Dll::SwitchToThreadAvailable()) { 3271 return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ; 3272 } else { 3273 Sleep(0); 3274 } 3275 return os::YIELD_UNKNOWN ; 3276 } 3277 3278 void os::yield() { os::NakedYield(); } 3279 3280 void os::yield_all(int attempts) { 3281 // Yields to all threads, including threads with lower priorities 3282 Sleep(1); 3283 } 3284 3285 // Win32 only gives you access to seven real priorities at a time, 3286 // so we compress Java's ten down to seven. It would be better 3287 // if we dynamically adjusted relative priorities. 3288 3289 int os::java_to_os_priority[MaxPriority + 1] = { 3290 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3291 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3292 THREAD_PRIORITY_LOWEST, // 2 3293 THREAD_PRIORITY_BELOW_NORMAL, // 3 3294 THREAD_PRIORITY_BELOW_NORMAL, // 4 3295 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3296 THREAD_PRIORITY_NORMAL, // 6 3297 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3298 THREAD_PRIORITY_ABOVE_NORMAL, // 8 3299 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3300 THREAD_PRIORITY_HIGHEST // 10 MaxPriority 3301 }; 3302 3303 int prio_policy1[MaxPriority + 1] = { 3304 THREAD_PRIORITY_IDLE, // 0 Entry should never be used 3305 THREAD_PRIORITY_LOWEST, // 1 MinPriority 3306 THREAD_PRIORITY_LOWEST, // 2 3307 THREAD_PRIORITY_BELOW_NORMAL, // 3 3308 THREAD_PRIORITY_BELOW_NORMAL, // 4 3309 THREAD_PRIORITY_NORMAL, // 5 NormPriority 3310 THREAD_PRIORITY_ABOVE_NORMAL, // 6 3311 THREAD_PRIORITY_ABOVE_NORMAL, // 7 3312 THREAD_PRIORITY_HIGHEST, // 8 3313 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority 3314 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority 3315 }; 3316 3317 static int prio_init() { 3318 // If ThreadPriorityPolicy is 1, switch tables 3319 if (ThreadPriorityPolicy == 1) { 3320 int i; 3321 for (i = 0; i < MaxPriority + 1; i++) { 3322 os::java_to_os_priority[i] = prio_policy1[i]; 3323 } 3324 } 3325 return 0; 3326 } 3327 3328 OSReturn os::set_native_priority(Thread* thread, int priority) { 3329 if (!UseThreadPriorities) return OS_OK; 3330 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0; 3331 return ret ? OS_OK : OS_ERR; 3332 } 3333 3334 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) { 3335 if ( !UseThreadPriorities ) { 3336 *priority_ptr = java_to_os_priority[NormPriority]; 3337 return OS_OK; 3338 } 3339 int os_prio = GetThreadPriority(thread->osthread()->thread_handle()); 3340 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) { 3341 assert(false, "GetThreadPriority failed"); 3342 return OS_ERR; 3343 } 3344 *priority_ptr = os_prio; 3345 return OS_OK; 3346 } 3347 3348 3349 // Hint to the underlying OS that a task switch would not be good. 3350 // Void return because it's a hint and can fail. 3351 void os::hint_no_preempt() {} 3352 3353 void os::interrupt(Thread* thread) { 3354 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3355 "possibility of dangling Thread pointer"); 3356 3357 OSThread* osthread = thread->osthread(); 3358 osthread->set_interrupted(true); 3359 // More than one thread can get here with the same value of osthread, 3360 // resulting in multiple notifications. We do, however, want the store 3361 // to interrupted() to be visible to other threads before we post 3362 // the interrupt event. 3363 OrderAccess::release(); 3364 SetEvent(osthread->interrupt_event()); 3365 // For JSR166: unpark after setting status 3366 if (thread->is_Java_thread()) 3367 ((JavaThread*)thread)->parker()->unpark(); 3368 3369 ParkEvent * ev = thread->_ParkEvent ; 3370 if (ev != NULL) ev->unpark() ; 3371 3372 } 3373 3374 3375 bool os::is_interrupted(Thread* thread, bool clear_interrupted) { 3376 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), 3377 "possibility of dangling Thread pointer"); 3378 3379 OSThread* osthread = thread->osthread(); 3380 bool interrupted = osthread->interrupted(); 3381 // There is no synchronization between the setting of the interrupt 3382 // and it being cleared here. It is critical - see 6535709 - that 3383 // we only clear the interrupt state, and reset the interrupt event, 3384 // if we are going to report that we were indeed interrupted - else 3385 // an interrupt can be "lost", leading to spurious wakeups or lost wakeups 3386 // depending on the timing 3387 if (interrupted && clear_interrupted) { 3388 osthread->set_interrupted(false); 3389 ResetEvent(osthread->interrupt_event()); 3390 } // Otherwise leave the interrupted state alone 3391 3392 return interrupted; 3393 } 3394 3395 // Get's a pc (hint) for a running thread. Currently used only for profiling. 3396 ExtendedPC os::get_thread_pc(Thread* thread) { 3397 CONTEXT context; 3398 context.ContextFlags = CONTEXT_CONTROL; 3399 HANDLE handle = thread->osthread()->thread_handle(); 3400 #ifdef _M_IA64 3401 assert(0, "Fix get_thread_pc"); 3402 return ExtendedPC(NULL); 3403 #else 3404 if (GetThreadContext(handle, &context)) { 3405 #ifdef _M_AMD64 3406 return ExtendedPC((address) context.Rip); 3407 #else 3408 return ExtendedPC((address) context.Eip); 3409 #endif 3410 } else { 3411 return ExtendedPC(NULL); 3412 } 3413 #endif 3414 } 3415 3416 // GetCurrentThreadId() returns DWORD 3417 intx os::current_thread_id() { return GetCurrentThreadId(); } 3418 3419 static int _initial_pid = 0; 3420 3421 int os::current_process_id() 3422 { 3423 return (_initial_pid ? _initial_pid : _getpid()); 3424 } 3425 3426 int os::win32::_vm_page_size = 0; 3427 int os::win32::_vm_allocation_granularity = 0; 3428 int os::win32::_processor_type = 0; 3429 // Processor level is not available on non-NT systems, use vm_version instead 3430 int os::win32::_processor_level = 0; 3431 julong os::win32::_physical_memory = 0; 3432 size_t os::win32::_default_stack_size = 0; 3433 3434 intx os::win32::_os_thread_limit = 0; 3435 volatile intx os::win32::_os_thread_count = 0; 3436 3437 bool os::win32::_is_nt = false; 3438 bool os::win32::_is_windows_2003 = false; 3439 bool os::win32::_is_windows_server = false; 3440 3441 void os::win32::initialize_system_info() { 3442 SYSTEM_INFO si; 3443 GetSystemInfo(&si); 3444 _vm_page_size = si.dwPageSize; 3445 _vm_allocation_granularity = si.dwAllocationGranularity; 3446 _processor_type = si.dwProcessorType; 3447 _processor_level = si.wProcessorLevel; 3448 set_processor_count(si.dwNumberOfProcessors); 3449 3450 MEMORYSTATUSEX ms; 3451 ms.dwLength = sizeof(ms); 3452 3453 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual, 3454 // dwMemoryLoad (% of memory in use) 3455 GlobalMemoryStatusEx(&ms); 3456 _physical_memory = ms.ullTotalPhys; 3457 3458 OSVERSIONINFOEX oi; 3459 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); 3460 GetVersionEx((OSVERSIONINFO*)&oi); 3461 switch(oi.dwPlatformId) { 3462 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break; 3463 case VER_PLATFORM_WIN32_NT: 3464 _is_nt = true; 3465 { 3466 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion; 3467 if (os_vers == 5002) { 3468 _is_windows_2003 = true; 3469 } 3470 if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER || 3471 oi.wProductType == VER_NT_SERVER) { 3472 _is_windows_server = true; 3473 } 3474 } 3475 break; 3476 default: fatal("Unknown platform"); 3477 } 3478 3479 _default_stack_size = os::current_stack_size(); 3480 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size"); 3481 assert((_default_stack_size & (_vm_page_size - 1)) == 0, 3482 "stack size not a multiple of page size"); 3483 3484 initialize_performance_counter(); 3485 3486 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is 3487 // known to deadlock the system, if the VM issues to thread operations with 3488 // a too high frequency, e.g., such as changing the priorities. 3489 // The 6000 seems to work well - no deadlocks has been notices on the test 3490 // programs that we have seen experience this problem. 3491 if (!os::win32::is_nt()) { 3492 StarvationMonitorInterval = 6000; 3493 } 3494 } 3495 3496 3497 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) { 3498 char path[MAX_PATH]; 3499 DWORD size; 3500 DWORD pathLen = (DWORD)sizeof(path); 3501 HINSTANCE result = NULL; 3502 3503 // only allow library name without path component 3504 assert(strchr(name, '\\') == NULL, "path not allowed"); 3505 assert(strchr(name, ':') == NULL, "path not allowed"); 3506 if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) { 3507 jio_snprintf(ebuf, ebuflen, 3508 "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name); 3509 return NULL; 3510 } 3511 3512 // search system directory 3513 if ((size = GetSystemDirectory(path, pathLen)) > 0) { 3514 strcat(path, "\\"); 3515 strcat(path, name); 3516 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) { 3517 return result; 3518 } 3519 } 3520 3521 // try Windows directory 3522 if ((size = GetWindowsDirectory(path, pathLen)) > 0) { 3523 strcat(path, "\\"); 3524 strcat(path, name); 3525 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) { 3526 return result; 3527 } 3528 } 3529 3530 jio_snprintf(ebuf, ebuflen, 3531 "os::win32::load_windows_dll() cannot load %s from system directories.", name); 3532 return NULL; 3533 } 3534 3535 void os::win32::setmode_streams() { 3536 _setmode(_fileno(stdin), _O_BINARY); 3537 _setmode(_fileno(stdout), _O_BINARY); 3538 _setmode(_fileno(stderr), _O_BINARY); 3539 } 3540 3541 3542 bool os::is_debugger_attached() { 3543 return IsDebuggerPresent() ? true : false; 3544 } 3545 3546 3547 void os::wait_for_keypress_at_exit(void) { 3548 if (PauseAtExit) { 3549 fprintf(stderr, "Press any key to continue...\n"); 3550 fgetc(stdin); 3551 } 3552 } 3553 3554 3555 int os::message_box(const char* title, const char* message) { 3556 int result = MessageBox(NULL, message, title, 3557 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY); 3558 return result == IDYES; 3559 } 3560 3561 int os::allocate_thread_local_storage() { 3562 return TlsAlloc(); 3563 } 3564 3565 3566 void os::free_thread_local_storage(int index) { 3567 TlsFree(index); 3568 } 3569 3570 3571 void os::thread_local_storage_at_put(int index, void* value) { 3572 TlsSetValue(index, value); 3573 assert(thread_local_storage_at(index) == value, "Just checking"); 3574 } 3575 3576 3577 void* os::thread_local_storage_at(int index) { 3578 return TlsGetValue(index); 3579 } 3580 3581 3582 #ifndef PRODUCT 3583 #ifndef _WIN64 3584 // Helpers to check whether NX protection is enabled 3585 int nx_exception_filter(_EXCEPTION_POINTERS *pex) { 3586 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && 3587 pex->ExceptionRecord->NumberParameters > 0 && 3588 pex->ExceptionRecord->ExceptionInformation[0] == 3589 EXCEPTION_INFO_EXEC_VIOLATION) { 3590 return EXCEPTION_EXECUTE_HANDLER; 3591 } 3592 return EXCEPTION_CONTINUE_SEARCH; 3593 } 3594 3595 void nx_check_protection() { 3596 // If NX is enabled we'll get an exception calling into code on the stack 3597 char code[] = { (char)0xC3 }; // ret 3598 void *code_ptr = (void *)code; 3599 __try { 3600 __asm call code_ptr 3601 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) { 3602 tty->print_raw_cr("NX protection detected."); 3603 } 3604 } 3605 #endif // _WIN64 3606 #endif // PRODUCT 3607 3608 // this is called _before_ the global arguments have been parsed 3609 void os::init(void) { 3610 _initial_pid = _getpid(); 3611 3612 init_random(1234567); 3613 3614 win32::initialize_system_info(); 3615 win32::setmode_streams(); 3616 init_page_sizes((size_t) win32::vm_page_size()); 3617 3618 // For better scalability on MP systems (must be called after initialize_system_info) 3619 #ifndef PRODUCT 3620 if (is_MP()) { 3621 NoYieldsInMicrolock = true; 3622 } 3623 #endif 3624 // This may be overridden later when argument processing is done. 3625 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation, 3626 os::win32::is_windows_2003()); 3627 3628 // Initialize main_process and main_thread 3629 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle 3630 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process, 3631 &main_thread, THREAD_ALL_ACCESS, false, 0)) { 3632 fatal("DuplicateHandle failed\n"); 3633 } 3634 main_thread_id = (int) GetCurrentThreadId(); 3635 } 3636 3637 // To install functions for atexit processing 3638 extern "C" { 3639 static void perfMemory_exit_helper() { 3640 perfMemory_exit(); 3641 } 3642 } 3643 3644 // this is called _after_ the global arguments have been parsed 3645 jint os::init_2(void) { 3646 // Allocate a single page and mark it as readable for safepoint polling 3647 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY); 3648 guarantee( polling_page != NULL, "Reserve Failed for polling page"); 3649 3650 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY); 3651 guarantee( return_page != NULL, "Commit Failed for polling page"); 3652 3653 os::set_polling_page( polling_page ); 3654 3655 #ifndef PRODUCT 3656 if( Verbose && PrintMiscellaneous ) 3657 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page); 3658 #endif 3659 3660 if (!UseMembar) { 3661 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE); 3662 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page"); 3663 3664 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE); 3665 guarantee( return_page != NULL, "Commit Failed for memory serialize page"); 3666 3667 os::set_memory_serialize_page( mem_serialize_page ); 3668 3669 #ifndef PRODUCT 3670 if(Verbose && PrintMiscellaneous) 3671 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page); 3672 #endif 3673 } 3674 3675 os::large_page_init(); 3676 3677 // Setup Windows Exceptions 3678 3679 // On Itanium systems, Structured Exception Handling does not 3680 // work since stack frames must be walkable by the OS. Since 3681 // much of our code is dynamically generated, and we do not have 3682 // proper unwind .xdata sections, the system simply exits 3683 // rather than delivering the exception. To work around 3684 // this we use VectorExceptions instead. 3685 #ifdef _WIN64 3686 if (UseVectoredExceptions) { 3687 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter); 3688 } 3689 #endif 3690 3691 // for debugging float code generation bugs 3692 if (ForceFloatExceptions) { 3693 #ifndef _WIN64 3694 static long fp_control_word = 0; 3695 __asm { fstcw fp_control_word } 3696 // see Intel PPro Manual, Vol. 2, p 7-16 3697 const long precision = 0x20; 3698 const long underflow = 0x10; 3699 const long overflow = 0x08; 3700 const long zero_div = 0x04; 3701 const long denorm = 0x02; 3702 const long invalid = 0x01; 3703 fp_control_word |= invalid; 3704 __asm { fldcw fp_control_word } 3705 #endif 3706 } 3707 3708 // If stack_commit_size is 0, windows will reserve the default size, 3709 // but only commit a small portion of it. 3710 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size()); 3711 size_t default_reserve_size = os::win32::default_stack_size(); 3712 size_t actual_reserve_size = stack_commit_size; 3713 if (stack_commit_size < default_reserve_size) { 3714 // If stack_commit_size == 0, we want this too 3715 actual_reserve_size = default_reserve_size; 3716 } 3717 3718 // Check minimum allowable stack size for thread creation and to initialize 3719 // the java system classes, including StackOverflowError - depends on page 3720 // size. Add a page for compiler2 recursion in main thread. 3721 // Add in 2*BytesPerWord times page size to account for VM stack during 3722 // class initialization depending on 32 or 64 bit VM. 3723 size_t min_stack_allowed = 3724 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+ 3725 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size(); 3726 if (actual_reserve_size < min_stack_allowed) { 3727 tty->print_cr("\nThe stack size specified is too small, " 3728 "Specify at least %dk", 3729 min_stack_allowed / K); 3730 return JNI_ERR; 3731 } 3732 3733 JavaThread::set_stack_size_at_create(stack_commit_size); 3734 3735 // Calculate theoretical max. size of Threads to guard gainst artifical 3736 // out-of-memory situations, where all available address-space has been 3737 // reserved by thread stacks. 3738 assert(actual_reserve_size != 0, "Must have a stack"); 3739 3740 // Calculate the thread limit when we should start doing Virtual Memory 3741 // banging. Currently when the threads will have used all but 200Mb of space. 3742 // 3743 // TODO: consider performing a similar calculation for commit size instead 3744 // as reserve size, since on a 64-bit platform we'll run into that more 3745 // often than running out of virtual memory space. We can use the 3746 // lower value of the two calculations as the os_thread_limit. 3747 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K); 3748 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size); 3749 3750 // at exit methods are called in the reverse order of their registration. 3751 // there is no limit to the number of functions registered. atexit does 3752 // not set errno. 3753 3754 if (PerfAllowAtExitRegistration) { 3755 // only register atexit functions if PerfAllowAtExitRegistration is set. 3756 // atexit functions can be delayed until process exit time, which 3757 // can be problematic for embedded VM situations. Embedded VMs should 3758 // call DestroyJavaVM() to assure that VM resources are released. 3759 3760 // note: perfMemory_exit_helper atexit function may be removed in 3761 // the future if the appropriate cleanup code can be added to the 3762 // VM_Exit VMOperation's doit method. 3763 if (atexit(perfMemory_exit_helper) != 0) { 3764 warning("os::init_2 atexit(perfMemory_exit_helper) failed"); 3765 } 3766 } 3767 3768 #ifndef _WIN64 3769 // Print something if NX is enabled (win32 on AMD64) 3770 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection()); 3771 #endif 3772 3773 // initialize thread priority policy 3774 prio_init(); 3775 3776 if (UseNUMA && !ForceNUMA) { 3777 UseNUMA = false; // We don't fully support this yet 3778 } 3779 3780 if (UseNUMAInterleaving) { 3781 // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag 3782 bool success = numa_interleaving_init(); 3783 if (!success) UseNUMAInterleaving = false; 3784 } 3785 3786 return JNI_OK; 3787 } 3788 3789 void os::init_3(void) { 3790 return; 3791 } 3792 3793 // Mark the polling page as unreadable 3794 void os::make_polling_page_unreadable(void) { 3795 DWORD old_status; 3796 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) ) 3797 fatal("Could not disable polling page"); 3798 }; 3799 3800 // Mark the polling page as readable 3801 void os::make_polling_page_readable(void) { 3802 DWORD old_status; 3803 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) ) 3804 fatal("Could not enable polling page"); 3805 }; 3806 3807 3808 int os::stat(const char *path, struct stat *sbuf) { 3809 char pathbuf[MAX_PATH]; 3810 if (strlen(path) > MAX_PATH - 1) { 3811 errno = ENAMETOOLONG; 3812 return -1; 3813 } 3814 os::native_path(strcpy(pathbuf, path)); 3815 int ret = ::stat(pathbuf, sbuf); 3816 if (sbuf != NULL && UseUTCFileTimestamp) { 3817 // Fix for 6539723. st_mtime returned from stat() is dependent on 3818 // the system timezone and so can return different values for the 3819 // same file if/when daylight savings time changes. This adjustment 3820 // makes sure the same timestamp is returned regardless of the TZ. 3821 // 3822 // See: 3823 // http://msdn.microsoft.com/library/ 3824 // default.asp?url=/library/en-us/sysinfo/base/ 3825 // time_zone_information_str.asp 3826 // and 3827 // http://msdn.microsoft.com/library/default.asp?url= 3828 // /library/en-us/sysinfo/base/settimezoneinformation.asp 3829 // 3830 // NOTE: there is a insidious bug here: If the timezone is changed 3831 // after the call to stat() but before 'GetTimeZoneInformation()', then 3832 // the adjustment we do here will be wrong and we'll return the wrong 3833 // value (which will likely end up creating an invalid class data 3834 // archive). Absent a better API for this, or some time zone locking 3835 // mechanism, we'll have to live with this risk. 3836 TIME_ZONE_INFORMATION tz; 3837 DWORD tzid = GetTimeZoneInformation(&tz); 3838 int daylightBias = 3839 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias; 3840 sbuf->st_mtime += (tz.Bias + daylightBias) * 60; 3841 } 3842 return ret; 3843 } 3844 3845 3846 #define FT2INT64(ft) \ 3847 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime)) 3848 3849 3850 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool) 3851 // are used by JVM M&M and JVMTI to get user+sys or user CPU time 3852 // of a thread. 3853 // 3854 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns 3855 // the fast estimate available on the platform. 3856 3857 // current_thread_cpu_time() is not optimized for Windows yet 3858 jlong os::current_thread_cpu_time() { 3859 // return user + sys since the cost is the same 3860 return os::thread_cpu_time(Thread::current(), true /* user+sys */); 3861 } 3862 3863 jlong os::thread_cpu_time(Thread* thread) { 3864 // consistent with what current_thread_cpu_time() returns. 3865 return os::thread_cpu_time(thread, true /* user+sys */); 3866 } 3867 3868 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) { 3869 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time); 3870 } 3871 3872 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) { 3873 // This code is copy from clasic VM -> hpi::sysThreadCPUTime 3874 // If this function changes, os::is_thread_cpu_time_supported() should too 3875 if (os::win32::is_nt()) { 3876 FILETIME CreationTime; 3877 FILETIME ExitTime; 3878 FILETIME KernelTime; 3879 FILETIME UserTime; 3880 3881 if ( GetThreadTimes(thread->osthread()->thread_handle(), 3882 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3883 return -1; 3884 else 3885 if (user_sys_cpu_time) { 3886 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100; 3887 } else { 3888 return FT2INT64(UserTime) * 100; 3889 } 3890 } else { 3891 return (jlong) timeGetTime() * 1000000; 3892 } 3893 } 3894 3895 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3896 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3897 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3898 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3899 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3900 } 3901 3902 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) { 3903 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits 3904 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time 3905 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time 3906 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned 3907 } 3908 3909 bool os::is_thread_cpu_time_supported() { 3910 // see os::thread_cpu_time 3911 if (os::win32::is_nt()) { 3912 FILETIME CreationTime; 3913 FILETIME ExitTime; 3914 FILETIME KernelTime; 3915 FILETIME UserTime; 3916 3917 if ( GetThreadTimes(GetCurrentThread(), 3918 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0) 3919 return false; 3920 else 3921 return true; 3922 } else { 3923 return false; 3924 } 3925 } 3926 3927 // Windows does't provide a loadavg primitive so this is stubbed out for now. 3928 // It does have primitives (PDH API) to get CPU usage and run queue length. 3929 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length" 3930 // If we wanted to implement loadavg on Windows, we have a few options: 3931 // 3932 // a) Query CPU usage and run queue length and "fake" an answer by 3933 // returning the CPU usage if it's under 100%, and the run queue 3934 // length otherwise. It turns out that querying is pretty slow 3935 // on Windows, on the order of 200 microseconds on a fast machine. 3936 // Note that on the Windows the CPU usage value is the % usage 3937 // since the last time the API was called (and the first call 3938 // returns 100%), so we'd have to deal with that as well. 3939 // 3940 // b) Sample the "fake" answer using a sampling thread and store 3941 // the answer in a global variable. The call to loadavg would 3942 // just return the value of the global, avoiding the slow query. 3943 // 3944 // c) Sample a better answer using exponential decay to smooth the 3945 // value. This is basically the algorithm used by UNIX kernels. 3946 // 3947 // Note that sampling thread starvation could affect both (b) and (c). 3948 int os::loadavg(double loadavg[], int nelem) { 3949 return -1; 3950 } 3951 3952 3953 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield() 3954 bool os::dont_yield() { 3955 return DontYieldALot; 3956 } 3957 3958 // This method is a slightly reworked copy of JDK's sysOpen 3959 // from src/windows/hpi/src/sys_api_md.c 3960 3961 int os::open(const char *path, int oflag, int mode) { 3962 char pathbuf[MAX_PATH]; 3963 3964 if (strlen(path) > MAX_PATH - 1) { 3965 errno = ENAMETOOLONG; 3966 return -1; 3967 } 3968 os::native_path(strcpy(pathbuf, path)); 3969 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode); 3970 } 3971 3972 // Is a (classpath) directory empty? 3973 bool os::dir_is_empty(const char* path) { 3974 WIN32_FIND_DATA fd; 3975 HANDLE f = FindFirstFile(path, &fd); 3976 if (f == INVALID_HANDLE_VALUE) { 3977 return true; 3978 } 3979 FindClose(f); 3980 return false; 3981 } 3982 3983 // create binary file, rewriting existing file if required 3984 int os::create_binary_file(const char* path, bool rewrite_existing) { 3985 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY; 3986 if (!rewrite_existing) { 3987 oflags |= _O_EXCL; 3988 } 3989 return ::open(path, oflags, _S_IREAD | _S_IWRITE); 3990 } 3991 3992 // return current position of file pointer 3993 jlong os::current_file_offset(int fd) { 3994 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR); 3995 } 3996 3997 // move file pointer to the specified offset 3998 jlong os::seek_to_file_offset(int fd, jlong offset) { 3999 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET); 4000 } 4001 4002 4003 jlong os::lseek(int fd, jlong offset, int whence) { 4004 return (jlong) ::_lseeki64(fd, offset, whence); 4005 } 4006 4007 // This method is a slightly reworked copy of JDK's sysNativePath 4008 // from src/windows/hpi/src/path_md.c 4009 4010 /* Convert a pathname to native format. On win32, this involves forcing all 4011 separators to be '\\' rather than '/' (both are legal inputs, but Win95 4012 sometimes rejects '/') and removing redundant separators. The input path is 4013 assumed to have been converted into the character encoding used by the local 4014 system. Because this might be a double-byte encoding, care is taken to 4015 treat double-byte lead characters correctly. 4016 4017 This procedure modifies the given path in place, as the result is never 4018 longer than the original. There is no error return; this operation always 4019 succeeds. */ 4020 char * os::native_path(char *path) { 4021 char *src = path, *dst = path, *end = path; 4022 char *colon = NULL; /* If a drive specifier is found, this will 4023 point to the colon following the drive 4024 letter */ 4025 4026 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */ 4027 assert(((!::IsDBCSLeadByte('/')) 4028 && (!::IsDBCSLeadByte('\\')) 4029 && (!::IsDBCSLeadByte(':'))), 4030 "Illegal lead byte"); 4031 4032 /* Check for leading separators */ 4033 #define isfilesep(c) ((c) == '/' || (c) == '\\') 4034 while (isfilesep(*src)) { 4035 src++; 4036 } 4037 4038 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') { 4039 /* Remove leading separators if followed by drive specifier. This 4040 hack is necessary to support file URLs containing drive 4041 specifiers (e.g., "file://c:/path"). As a side effect, 4042 "/c:/path" can be used as an alternative to "c:/path". */ 4043 *dst++ = *src++; 4044 colon = dst; 4045 *dst++ = ':'; 4046 src++; 4047 } else { 4048 src = path; 4049 if (isfilesep(src[0]) && isfilesep(src[1])) { 4050 /* UNC pathname: Retain first separator; leave src pointed at 4051 second separator so that further separators will be collapsed 4052 into the second separator. The result will be a pathname 4053 beginning with "\\\\" followed (most likely) by a host name. */ 4054 src = dst = path + 1; 4055 path[0] = '\\'; /* Force first separator to '\\' */ 4056 } 4057 } 4058 4059 end = dst; 4060 4061 /* Remove redundant separators from remainder of path, forcing all 4062 separators to be '\\' rather than '/'. Also, single byte space 4063 characters are removed from the end of the path because those 4064 are not legal ending characters on this operating system. 4065 */ 4066 while (*src != '\0') { 4067 if (isfilesep(*src)) { 4068 *dst++ = '\\'; src++; 4069 while (isfilesep(*src)) src++; 4070 if (*src == '\0') { 4071 /* Check for trailing separator */ 4072 end = dst; 4073 if (colon == dst - 2) break; /* "z:\\" */ 4074 if (dst == path + 1) break; /* "\\" */ 4075 if (dst == path + 2 && isfilesep(path[0])) { 4076 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the 4077 beginning of a UNC pathname. Even though it is not, by 4078 itself, a valid UNC pathname, we leave it as is in order 4079 to be consistent with the path canonicalizer as well 4080 as the win32 APIs, which treat this case as an invalid 4081 UNC pathname rather than as an alias for the root 4082 directory of the current drive. */ 4083 break; 4084 } 4085 end = --dst; /* Path does not denote a root directory, so 4086 remove trailing separator */ 4087 break; 4088 } 4089 end = dst; 4090 } else { 4091 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */ 4092 *dst++ = *src++; 4093 if (*src) *dst++ = *src++; 4094 end = dst; 4095 } else { /* Copy a single-byte character */ 4096 char c = *src++; 4097 *dst++ = c; 4098 /* Space is not a legal ending character */ 4099 if (c != ' ') end = dst; 4100 } 4101 } 4102 } 4103 4104 *end = '\0'; 4105 4106 /* For "z:", add "." to work around a bug in the C runtime library */ 4107 if (colon == dst - 1) { 4108 path[2] = '.'; 4109 path[3] = '\0'; 4110 } 4111 4112 #ifdef DEBUG 4113 jio_fprintf(stderr, "sysNativePath: %s\n", path); 4114 #endif DEBUG 4115 return path; 4116 } 4117 4118 // This code is a copy of JDK's sysSetLength 4119 // from src/windows/hpi/src/sys_api_md.c 4120 4121 int os::ftruncate(int fd, jlong length) { 4122 HANDLE h = (HANDLE)::_get_osfhandle(fd); 4123 long high = (long)(length >> 32); 4124 DWORD ret; 4125 4126 if (h == (HANDLE)(-1)) { 4127 return -1; 4128 } 4129 4130 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN); 4131 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) { 4132 return -1; 4133 } 4134 4135 if (::SetEndOfFile(h) == FALSE) { 4136 return -1; 4137 } 4138 4139 return 0; 4140 } 4141 4142 4143 // This code is a copy of JDK's sysSync 4144 // from src/windows/hpi/src/sys_api_md.c 4145 // except for the legacy workaround for a bug in Win 98 4146 4147 int os::fsync(int fd) { 4148 HANDLE handle = (HANDLE)::_get_osfhandle(fd); 4149 4150 if ( (!::FlushFileBuffers(handle)) && 4151 (GetLastError() != ERROR_ACCESS_DENIED) ) { 4152 /* from winerror.h */ 4153 return -1; 4154 } 4155 return 0; 4156 } 4157 4158 static int nonSeekAvailable(int, long *); 4159 static int stdinAvailable(int, long *); 4160 4161 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR) 4162 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO) 4163 4164 // This code is a copy of JDK's sysAvailable 4165 // from src/windows/hpi/src/sys_api_md.c 4166 4167 int os::available(int fd, jlong *bytes) { 4168 jlong cur, end; 4169 struct _stati64 stbuf64; 4170 4171 if (::_fstati64(fd, &stbuf64) >= 0) { 4172 int mode = stbuf64.st_mode; 4173 if (S_ISCHR(mode) || S_ISFIFO(mode)) { 4174 int ret; 4175 long lpbytes; 4176 if (fd == 0) { 4177 ret = stdinAvailable(fd, &lpbytes); 4178 } else { 4179 ret = nonSeekAvailable(fd, &lpbytes); 4180 } 4181 (*bytes) = (jlong)(lpbytes); 4182 return ret; 4183 } 4184 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) { 4185 return FALSE; 4186 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) { 4187 return FALSE; 4188 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) { 4189 return FALSE; 4190 } 4191 *bytes = end - cur; 4192 return TRUE; 4193 } else { 4194 return FALSE; 4195 } 4196 } 4197 4198 // This code is a copy of JDK's nonSeekAvailable 4199 // from src/windows/hpi/src/sys_api_md.c 4200 4201 static int nonSeekAvailable(int fd, long *pbytes) { 4202 /* This is used for available on non-seekable devices 4203 * (like both named and anonymous pipes, such as pipes 4204 * connected to an exec'd process). 4205 * Standard Input is a special case. 4206 * 4207 */ 4208 HANDLE han; 4209 4210 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) { 4211 return FALSE; 4212 } 4213 4214 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) { 4215 /* PeekNamedPipe fails when at EOF. In that case we 4216 * simply make *pbytes = 0 which is consistent with the 4217 * behavior we get on Solaris when an fd is at EOF. 4218 * The only alternative is to raise an Exception, 4219 * which isn't really warranted. 4220 */ 4221 if (::GetLastError() != ERROR_BROKEN_PIPE) { 4222 return FALSE; 4223 } 4224 *pbytes = 0; 4225 } 4226 return TRUE; 4227 } 4228 4229 #define MAX_INPUT_EVENTS 2000 4230 4231 // This code is a copy of JDK's stdinAvailable 4232 // from src/windows/hpi/src/sys_api_md.c 4233 4234 static int stdinAvailable(int fd, long *pbytes) { 4235 HANDLE han; 4236 DWORD numEventsRead = 0; /* Number of events read from buffer */ 4237 DWORD numEvents = 0; /* Number of events in buffer */ 4238 DWORD i = 0; /* Loop index */ 4239 DWORD curLength = 0; /* Position marker */ 4240 DWORD actualLength = 0; /* Number of bytes readable */ 4241 BOOL error = FALSE; /* Error holder */ 4242 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */ 4243 4244 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) { 4245 return FALSE; 4246 } 4247 4248 /* Construct an array of input records in the console buffer */ 4249 error = ::GetNumberOfConsoleInputEvents(han, &numEvents); 4250 if (error == 0) { 4251 return nonSeekAvailable(fd, pbytes); 4252 } 4253 4254 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */ 4255 if (numEvents > MAX_INPUT_EVENTS) { 4256 numEvents = MAX_INPUT_EVENTS; 4257 } 4258 4259 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD)); 4260 if (lpBuffer == NULL) { 4261 return FALSE; 4262 } 4263 4264 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead); 4265 if (error == 0) { 4266 os::free(lpBuffer); 4267 return FALSE; 4268 } 4269 4270 /* Examine input records for the number of bytes available */ 4271 for(i=0; i<numEvents; i++) { 4272 if (lpBuffer[i].EventType == KEY_EVENT) { 4273 4274 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *) 4275 &(lpBuffer[i].Event); 4276 if (keyRecord->bKeyDown == TRUE) { 4277 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar); 4278 curLength++; 4279 if (*keyPressed == '\r') { 4280 actualLength = curLength; 4281 } 4282 } 4283 } 4284 } 4285 4286 if(lpBuffer != NULL) { 4287 os::free(lpBuffer); 4288 } 4289 4290 *pbytes = (long) actualLength; 4291 return TRUE; 4292 } 4293 4294 // Map a block of memory. 4295 char* os::map_memory(int fd, const char* file_name, size_t file_offset, 4296 char *addr, size_t bytes, bool read_only, 4297 bool allow_exec) { 4298 HANDLE hFile; 4299 char* base; 4300 4301 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, 4302 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); 4303 if (hFile == NULL) { 4304 if (PrintMiscellaneous && Verbose) { 4305 DWORD err = GetLastError(); 4306 tty->print_cr("CreateFile() failed: GetLastError->%ld."); 4307 } 4308 return NULL; 4309 } 4310 4311 if (allow_exec) { 4312 // CreateFileMapping/MapViewOfFileEx can't map executable memory 4313 // unless it comes from a PE image (which the shared archive is not.) 4314 // Even VirtualProtect refuses to give execute access to mapped memory 4315 // that was not previously executable. 4316 // 4317 // Instead, stick the executable region in anonymous memory. Yuck. 4318 // Penalty is that ~4 pages will not be shareable - in the future 4319 // we might consider DLLizing the shared archive with a proper PE 4320 // header so that mapping executable + sharing is possible. 4321 4322 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE, 4323 PAGE_READWRITE); 4324 if (base == NULL) { 4325 if (PrintMiscellaneous && Verbose) { 4326 DWORD err = GetLastError(); 4327 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err); 4328 } 4329 CloseHandle(hFile); 4330 return NULL; 4331 } 4332 4333 DWORD bytes_read; 4334 OVERLAPPED overlapped; 4335 overlapped.Offset = (DWORD)file_offset; 4336 overlapped.OffsetHigh = 0; 4337 overlapped.hEvent = NULL; 4338 // ReadFile guarantees that if the return value is true, the requested 4339 // number of bytes were read before returning. 4340 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0; 4341 if (!res) { 4342 if (PrintMiscellaneous && Verbose) { 4343 DWORD err = GetLastError(); 4344 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err); 4345 } 4346 release_memory(base, bytes); 4347 CloseHandle(hFile); 4348 return NULL; 4349 } 4350 } else { 4351 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0, 4352 NULL /*file_name*/); 4353 if (hMap == NULL) { 4354 if (PrintMiscellaneous && Verbose) { 4355 DWORD err = GetLastError(); 4356 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld."); 4357 } 4358 CloseHandle(hFile); 4359 return NULL; 4360 } 4361 4362 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY; 4363 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset, 4364 (DWORD)bytes, addr); 4365 if (base == NULL) { 4366 if (PrintMiscellaneous && Verbose) { 4367 DWORD err = GetLastError(); 4368 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err); 4369 } 4370 CloseHandle(hMap); 4371 CloseHandle(hFile); 4372 return NULL; 4373 } 4374 4375 if (CloseHandle(hMap) == 0) { 4376 if (PrintMiscellaneous && Verbose) { 4377 DWORD err = GetLastError(); 4378 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err); 4379 } 4380 CloseHandle(hFile); 4381 return base; 4382 } 4383 } 4384 4385 if (allow_exec) { 4386 DWORD old_protect; 4387 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE; 4388 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0; 4389 4390 if (!res) { 4391 if (PrintMiscellaneous && Verbose) { 4392 DWORD err = GetLastError(); 4393 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err); 4394 } 4395 // Don't consider this a hard error, on IA32 even if the 4396 // VirtualProtect fails, we should still be able to execute 4397 CloseHandle(hFile); 4398 return base; 4399 } 4400 } 4401 4402 if (CloseHandle(hFile) == 0) { 4403 if (PrintMiscellaneous && Verbose) { 4404 DWORD err = GetLastError(); 4405 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err); 4406 } 4407 return base; 4408 } 4409 4410 return base; 4411 } 4412 4413 4414 // Remap a block of memory. 4415 char* os::remap_memory(int fd, const char* file_name, size_t file_offset, 4416 char *addr, size_t bytes, bool read_only, 4417 bool allow_exec) { 4418 // This OS does not allow existing memory maps to be remapped so we 4419 // have to unmap the memory before we remap it. 4420 if (!os::unmap_memory(addr, bytes)) { 4421 return NULL; 4422 } 4423 4424 // There is a very small theoretical window between the unmap_memory() 4425 // call above and the map_memory() call below where a thread in native 4426 // code may be able to access an address that is no longer mapped. 4427 4428 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only, 4429 allow_exec); 4430 } 4431 4432 4433 // Unmap a block of memory. 4434 // Returns true=success, otherwise false. 4435 4436 bool os::unmap_memory(char* addr, size_t bytes) { 4437 BOOL result = UnmapViewOfFile(addr); 4438 if (result == 0) { 4439 if (PrintMiscellaneous && Verbose) { 4440 DWORD err = GetLastError(); 4441 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err); 4442 } 4443 return false; 4444 } 4445 return true; 4446 } 4447 4448 void os::pause() { 4449 char filename[MAX_PATH]; 4450 if (PauseAtStartupFile && PauseAtStartupFile[0]) { 4451 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile); 4452 } else { 4453 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id()); 4454 } 4455 4456 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666); 4457 if (fd != -1) { 4458 struct stat buf; 4459 ::close(fd); 4460 while (::stat(filename, &buf) == 0) { 4461 Sleep(100); 4462 } 4463 } else { 4464 jio_fprintf(stderr, 4465 "Could not open pause file '%s', continuing immediately.\n", filename); 4466 } 4467 } 4468 4469 // An Event wraps a win32 "CreateEvent" kernel handle. 4470 // 4471 // We have a number of choices regarding "CreateEvent" win32 handle leakage: 4472 // 4473 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle 4474 // field, and call CloseHandle() on the win32 event handle. Unpark() would 4475 // need to be modified to tolerate finding a NULL (invalid) win32 event handle. 4476 // In addition, an unpark() operation might fetch the handle field, but the 4477 // event could recycle between the fetch and the SetEvent() operation. 4478 // SetEvent() would either fail because the handle was invalid, or inadvertently work, 4479 // as the win32 handle value had been recycled. In an ideal world calling SetEvent() 4480 // on an stale but recycled handle would be harmless, but in practice this might 4481 // confuse other non-Sun code, so it's not a viable approach. 4482 // 4483 // 2: Once a win32 event handle is associated with an Event, it remains associated 4484 // with the Event. The event handle is never closed. This could be construed 4485 // as handle leakage, but only up to the maximum # of threads that have been extant 4486 // at any one time. This shouldn't be an issue, as windows platforms typically 4487 // permit a process to have hundreds of thousands of open handles. 4488 // 4489 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList 4490 // and release unused handles. 4491 // 4492 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle. 4493 // It's not clear, however, that we wouldn't be trading one type of leak for another. 4494 // 4495 // 5. Use an RCU-like mechanism (Read-Copy Update). 4496 // Or perhaps something similar to Maged Michael's "Hazard pointers". 4497 // 4498 // We use (2). 4499 // 4500 // TODO-FIXME: 4501 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation. 4502 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks 4503 // to recover from (or at least detect) the dreaded Windows 841176 bug. 4504 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent 4505 // into a single win32 CreateEvent() handle. 4506 // 4507 // _Event transitions in park() 4508 // -1 => -1 : illegal 4509 // 1 => 0 : pass - return immediately 4510 // 0 => -1 : block 4511 // 4512 // _Event serves as a restricted-range semaphore : 4513 // -1 : thread is blocked 4514 // 0 : neutral - thread is running or ready 4515 // 1 : signaled - thread is running or ready 4516 // 4517 // Another possible encoding of _Event would be 4518 // with explicit "PARKED" and "SIGNALED" bits. 4519 4520 int os::PlatformEvent::park (jlong Millis) { 4521 guarantee (_ParkHandle != NULL , "Invariant") ; 4522 guarantee (Millis > 0 , "Invariant") ; 4523 int v ; 4524 4525 // CONSIDER: defer assigning a CreateEvent() handle to the Event until 4526 // the initial park() operation. 4527 4528 for (;;) { 4529 v = _Event ; 4530 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4531 } 4532 guarantee ((v == 0) || (v == 1), "invariant") ; 4533 if (v != 0) return OS_OK ; 4534 4535 // Do this the hard way by blocking ... 4536 // TODO: consider a brief spin here, gated on the success of recent 4537 // spin attempts by this thread. 4538 // 4539 // We decompose long timeouts into series of shorter timed waits. 4540 // Evidently large timo values passed in WaitForSingleObject() are problematic on some 4541 // versions of Windows. See EventWait() for details. This may be superstition. Or not. 4542 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time 4543 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from 4544 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend 4545 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv == 4546 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate 4547 // for the already waited time. This policy does not admit any new outcomes. 4548 // In the future, however, we might want to track the accumulated wait time and 4549 // adjust Millis accordingly if we encounter a spurious wakeup. 4550 4551 const int MAXTIMEOUT = 0x10000000 ; 4552 DWORD rv = WAIT_TIMEOUT ; 4553 while (_Event < 0 && Millis > 0) { 4554 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT) 4555 if (Millis > MAXTIMEOUT) { 4556 prd = MAXTIMEOUT ; 4557 } 4558 rv = ::WaitForSingleObject (_ParkHandle, prd) ; 4559 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ; 4560 if (rv == WAIT_TIMEOUT) { 4561 Millis -= prd ; 4562 } 4563 } 4564 v = _Event ; 4565 _Event = 0 ; 4566 OrderAccess::fence() ; 4567 // If we encounter a nearly simultanous timeout expiry and unpark() 4568 // we return OS_OK indicating we awoke via unpark(). 4569 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however. 4570 return (v >= 0) ? OS_OK : OS_TIMEOUT ; 4571 } 4572 4573 void os::PlatformEvent::park () { 4574 guarantee (_ParkHandle != NULL, "Invariant") ; 4575 // Invariant: Only the thread associated with the Event/PlatformEvent 4576 // may call park(). 4577 int v ; 4578 for (;;) { 4579 v = _Event ; 4580 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; 4581 } 4582 guarantee ((v == 0) || (v == 1), "invariant") ; 4583 if (v != 0) return ; 4584 4585 // Do this the hard way by blocking ... 4586 // TODO: consider a brief spin here, gated on the success of recent 4587 // spin attempts by this thread. 4588 while (_Event < 0) { 4589 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ; 4590 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ; 4591 } 4592 4593 // Usually we'll find _Event == 0 at this point, but as 4594 // an optional optimization we clear it, just in case can 4595 // multiple unpark() operations drove _Event up to 1. 4596 _Event = 0 ; 4597 OrderAccess::fence() ; 4598 guarantee (_Event >= 0, "invariant") ; 4599 } 4600 4601 void os::PlatformEvent::unpark() { 4602 guarantee (_ParkHandle != NULL, "Invariant") ; 4603 int v ; 4604 for (;;) { 4605 v = _Event ; // Increment _Event if it's < 1. 4606 if (v > 0) { 4607 // If it's already signaled just return. 4608 // The LD of _Event could have reordered or be satisfied 4609 // by a read-aside from this processor's write buffer. 4610 // To avoid problems execute a barrier and then 4611 // ratify the value. A degenerate CAS() would also work. 4612 // Viz., CAS (v+0, &_Event, v) == v). 4613 OrderAccess::fence() ; 4614 if (_Event == v) return ; 4615 continue ; 4616 } 4617 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ; 4618 } 4619 if (v < 0) { 4620 ::SetEvent (_ParkHandle) ; 4621 } 4622 } 4623 4624 4625 // JSR166 4626 // ------------------------------------------------------- 4627 4628 /* 4629 * The Windows implementation of Park is very straightforward: Basic 4630 * operations on Win32 Events turn out to have the right semantics to 4631 * use them directly. We opportunistically resuse the event inherited 4632 * from Monitor. 4633 */ 4634 4635 4636 void Parker::park(bool isAbsolute, jlong time) { 4637 guarantee (_ParkEvent != NULL, "invariant") ; 4638 // First, demultiplex/decode time arguments 4639 if (time < 0) { // don't wait 4640 return; 4641 } 4642 else if (time == 0 && !isAbsolute) { 4643 time = INFINITE; 4644 } 4645 else if (isAbsolute) { 4646 time -= os::javaTimeMillis(); // convert to relative time 4647 if (time <= 0) // already elapsed 4648 return; 4649 } 4650 else { // relative 4651 time /= 1000000; // Must coarsen from nanos to millis 4652 if (time == 0) // Wait for the minimal time unit if zero 4653 time = 1; 4654 } 4655 4656 JavaThread* thread = (JavaThread*)(Thread::current()); 4657 assert(thread->is_Java_thread(), "Must be JavaThread"); 4658 JavaThread *jt = (JavaThread *)thread; 4659 4660 // Don't wait if interrupted or already triggered 4661 if (Thread::is_interrupted(thread, false) || 4662 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) { 4663 ResetEvent(_ParkEvent); 4664 return; 4665 } 4666 else { 4667 ThreadBlockInVM tbivm(jt); 4668 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */); 4669 jt->set_suspend_equivalent(); 4670 4671 WaitForSingleObject(_ParkEvent, time); 4672 ResetEvent(_ParkEvent); 4673 4674 // If externally suspended while waiting, re-suspend 4675 if (jt->handle_special_suspend_equivalent_condition()) { 4676 jt->java_suspend_self(); 4677 } 4678 } 4679 } 4680 4681 void Parker::unpark() { 4682 guarantee (_ParkEvent != NULL, "invariant") ; 4683 SetEvent(_ParkEvent); 4684 } 4685 4686 // Run the specified command in a separate process. Return its exit value, 4687 // or -1 on failure (e.g. can't create a new process). 4688 int os::fork_and_exec(char* cmd) { 4689 STARTUPINFO si; 4690 PROCESS_INFORMATION pi; 4691 4692 memset(&si, 0, sizeof(si)); 4693 si.cb = sizeof(si); 4694 memset(&pi, 0, sizeof(pi)); 4695 BOOL rslt = CreateProcess(NULL, // executable name - use command line 4696 cmd, // command line 4697 NULL, // process security attribute 4698 NULL, // thread security attribute 4699 TRUE, // inherits system handles 4700 0, // no creation flags 4701 NULL, // use parent's environment block 4702 NULL, // use parent's starting directory 4703 &si, // (in) startup information 4704 &pi); // (out) process information 4705 4706 if (rslt) { 4707 // Wait until child process exits. 4708 WaitForSingleObject(pi.hProcess, INFINITE); 4709 4710 DWORD exit_code; 4711 GetExitCodeProcess(pi.hProcess, &exit_code); 4712 4713 // Close process and thread handles. 4714 CloseHandle(pi.hProcess); 4715 CloseHandle(pi.hThread); 4716 4717 return (int)exit_code; 4718 } else { 4719 return -1; 4720 } 4721 } 4722 4723 //-------------------------------------------------------------------------------------------------- 4724 // Non-product code 4725 4726 static int mallocDebugIntervalCounter = 0; 4727 static int mallocDebugCounter = 0; 4728 bool os::check_heap(bool force) { 4729 if (++mallocDebugCounter < MallocVerifyStart && !force) return true; 4730 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) { 4731 // Note: HeapValidate executes two hardware breakpoints when it finds something 4732 // wrong; at these points, eax contains the address of the offending block (I think). 4733 // To get to the exlicit error message(s) below, just continue twice. 4734 HANDLE heap = GetProcessHeap(); 4735 { HeapLock(heap); 4736 PROCESS_HEAP_ENTRY phe; 4737 phe.lpData = NULL; 4738 while (HeapWalk(heap, &phe) != 0) { 4739 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) && 4740 !HeapValidate(heap, 0, phe.lpData)) { 4741 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter); 4742 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData); 4743 fatal("corrupted C heap"); 4744 } 4745 } 4746 int err = GetLastError(); 4747 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) { 4748 fatal(err_msg("heap walk aborted with error %d", err)); 4749 } 4750 HeapUnlock(heap); 4751 } 4752 mallocDebugIntervalCounter = 0; 4753 } 4754 return true; 4755 } 4756 4757 4758 bool os::find(address addr, outputStream* st) { 4759 // Nothing yet 4760 return false; 4761 } 4762 4763 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) { 4764 DWORD exception_code = e->ExceptionRecord->ExceptionCode; 4765 4766 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) { 4767 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow(); 4768 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord; 4769 address addr = (address) exceptionRecord->ExceptionInformation[1]; 4770 4771 if (os::is_memory_serialize_page(thread, addr)) 4772 return EXCEPTION_CONTINUE_EXECUTION; 4773 } 4774 4775 return EXCEPTION_CONTINUE_SEARCH; 4776 } 4777 4778 static int getLastErrorString(char *buf, size_t len) 4779 { 4780 long errval; 4781 4782 if ((errval = GetLastError()) != 0) 4783 { 4784 /* DOS error */ 4785 size_t n = (size_t)FormatMessage( 4786 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, 4787 NULL, 4788 errval, 4789 0, 4790 buf, 4791 (DWORD)len, 4792 NULL); 4793 if (n > 3) { 4794 /* Drop final '.', CR, LF */ 4795 if (buf[n - 1] == '\n') n--; 4796 if (buf[n - 1] == '\r') n--; 4797 if (buf[n - 1] == '.') n--; 4798 buf[n] = '\0'; 4799 } 4800 return (int)n; 4801 } 4802 4803 if (errno != 0) 4804 { 4805 /* C runtime error that has no corresponding DOS error code */ 4806 const char *s = strerror(errno); 4807 size_t n = strlen(s); 4808 if (n >= len) n = len - 1; 4809 strncpy(buf, s, n); 4810 buf[n] = '\0'; 4811 return (int)n; 4812 } 4813 return 0; 4814 } 4815 4816 4817 // We don't build a headless jre for Windows 4818 bool os::is_headless_jre() { return false; } 4819 4820 4821 typedef CRITICAL_SECTION mutex_t; 4822 #define mutexInit(m) InitializeCriticalSection(m) 4823 #define mutexDestroy(m) DeleteCriticalSection(m) 4824 #define mutexLock(m) EnterCriticalSection(m) 4825 #define mutexUnlock(m) LeaveCriticalSection(m) 4826 4827 static bool sock_initialized = FALSE; 4828 static mutex_t sockFnTableMutex; 4829 4830 static void initSock() { 4831 WSADATA wsadata; 4832 4833 if (!os::WinSock2Dll::WinSock2Available()) { 4834 jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n", 4835 ::GetLastError()); 4836 return; 4837 } 4838 if (sock_initialized == TRUE) return; 4839 4840 ::mutexInit(&sockFnTableMutex); 4841 ::mutexLock(&sockFnTableMutex); 4842 if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) { 4843 jio_fprintf(stderr, "Could not initialize Winsock\n"); 4844 } 4845 sock_initialized = TRUE; 4846 ::mutexUnlock(&sockFnTableMutex); 4847 } 4848 4849 struct hostent* os::get_host_by_name(char* name) { 4850 if (!sock_initialized) { 4851 initSock(); 4852 } 4853 if (!os::WinSock2Dll::WinSock2Available()) { 4854 return NULL; 4855 } 4856 return (struct hostent*)os::WinSock2Dll::gethostbyname(name); 4857 } 4858 4859 4860 int os::socket_close(int fd) { 4861 ShouldNotReachHere(); 4862 return 0; 4863 } 4864 4865 int os::socket_available(int fd, jint *pbytes) { 4866 ShouldNotReachHere(); 4867 return 0; 4868 } 4869 4870 int os::socket(int domain, int type, int protocol) { 4871 ShouldNotReachHere(); 4872 return 0; 4873 } 4874 4875 int os::listen(int fd, int count) { 4876 ShouldNotReachHere(); 4877 return 0; 4878 } 4879 4880 int os::connect(int fd, struct sockaddr *him, int len) { 4881 ShouldNotReachHere(); 4882 return 0; 4883 } 4884 4885 int os::accept(int fd, struct sockaddr *him, int *len) { 4886 ShouldNotReachHere(); 4887 return 0; 4888 } 4889 4890 int os::sendto(int fd, char *buf, int len, int flags, 4891 struct sockaddr *to, int tolen) { 4892 ShouldNotReachHere(); 4893 return 0; 4894 } 4895 4896 int os::recvfrom(int fd, char *buf, int nBytes, int flags, 4897 sockaddr *from, int *fromlen) { 4898 ShouldNotReachHere(); 4899 return 0; 4900 } 4901 4902 int os::recv(int fd, char *buf, int nBytes, int flags) { 4903 ShouldNotReachHere(); 4904 return 0; 4905 } 4906 4907 int os::send(int fd, char *buf, int nBytes, int flags) { 4908 ShouldNotReachHere(); 4909 return 0; 4910 } 4911 4912 int os::raw_send(int fd, char *buf, int nBytes, int flags) { 4913 ShouldNotReachHere(); 4914 return 0; 4915 } 4916 4917 int os::timeout(int fd, long timeout) { 4918 ShouldNotReachHere(); 4919 return 0; 4920 } 4921 4922 int os::get_host_name(char* name, int namelen) { 4923 ShouldNotReachHere(); 4924 return 0; 4925 } 4926 4927 int os::socket_shutdown(int fd, int howto) { 4928 ShouldNotReachHere(); 4929 return 0; 4930 } 4931 4932 int os::bind(int fd, struct sockaddr *him, int len) { 4933 ShouldNotReachHere(); 4934 return 0; 4935 } 4936 4937 int os::get_sock_name(int fd, struct sockaddr *him, int *len) { 4938 ShouldNotReachHere(); 4939 return 0; 4940 } 4941 4942 int os::get_sock_opt(int fd, int level, int optname, 4943 char *optval, int* optlen) { 4944 ShouldNotReachHere(); 4945 return 0; 4946 } 4947 4948 int os::set_sock_opt(int fd, int level, int optname, 4949 const char *optval, int optlen) { 4950 ShouldNotReachHere(); 4951 return 0; 4952 } 4953 4954 4955 // Kernel32 API 4956 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void); 4957 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD); 4958 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG); 4959 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG); 4960 4961 GetLargePageMinimum_Fn os::Kernel32Dll::_GetLargePageMinimum = NULL; 4962 VirtualAllocExNuma_Fn os::Kernel32Dll::_VirtualAllocExNuma = NULL; 4963 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL; 4964 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL; 4965 BOOL os::Kernel32Dll::initialized = FALSE; 4966 SIZE_T os::Kernel32Dll::GetLargePageMinimum() { 4967 assert(initialized && _GetLargePageMinimum != NULL, 4968 "GetLargePageMinimumAvailable() not yet called"); 4969 return _GetLargePageMinimum(); 4970 } 4971 4972 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() { 4973 if (!initialized) { 4974 initialize(); 4975 } 4976 return _GetLargePageMinimum != NULL; 4977 } 4978 4979 BOOL os::Kernel32Dll::NumaCallsAvailable() { 4980 if (!initialized) { 4981 initialize(); 4982 } 4983 return _VirtualAllocExNuma != NULL; 4984 } 4985 4986 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) { 4987 assert(initialized && _VirtualAllocExNuma != NULL, 4988 "NUMACallsAvailable() not yet called"); 4989 4990 return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node); 4991 } 4992 4993 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) { 4994 assert(initialized && _GetNumaHighestNodeNumber != NULL, 4995 "NUMACallsAvailable() not yet called"); 4996 4997 return _GetNumaHighestNodeNumber(ptr_highest_node_number); 4998 } 4999 5000 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) { 5001 assert(initialized && _GetNumaNodeProcessorMask != NULL, 5002 "NUMACallsAvailable() not yet called"); 5003 5004 return _GetNumaNodeProcessorMask(node, proc_mask); 5005 } 5006 5007 5008 void os::Kernel32Dll::initializeCommon() { 5009 if (!initialized) { 5010 HMODULE handle = ::GetModuleHandle("Kernel32.dll"); 5011 assert(handle != NULL, "Just check"); 5012 _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum"); 5013 _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma"); 5014 _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber"); 5015 _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask"); 5016 initialized = TRUE; 5017 } 5018 } 5019 5020 5021 5022 #ifndef JDK6_OR_EARLIER 5023 5024 void os::Kernel32Dll::initialize() { 5025 initializeCommon(); 5026 } 5027 5028 5029 // Kernel32 API 5030 inline BOOL os::Kernel32Dll::SwitchToThread() { 5031 return ::SwitchToThread(); 5032 } 5033 5034 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() { 5035 return true; 5036 } 5037 5038 // Help tools 5039 inline BOOL os::Kernel32Dll::HelpToolsAvailable() { 5040 return true; 5041 } 5042 5043 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) { 5044 return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId); 5045 } 5046 5047 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) { 5048 return ::Module32First(hSnapshot, lpme); 5049 } 5050 5051 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) { 5052 return ::Module32Next(hSnapshot, lpme); 5053 } 5054 5055 5056 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() { 5057 return true; 5058 } 5059 5060 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) { 5061 ::GetNativeSystemInfo(lpSystemInfo); 5062 } 5063 5064 // PSAPI API 5065 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) { 5066 return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded); 5067 } 5068 5069 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) { 5070 return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize); 5071 } 5072 5073 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) { 5074 return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb); 5075 } 5076 5077 inline BOOL os::PSApiDll::PSApiAvailable() { 5078 return true; 5079 } 5080 5081 5082 // WinSock2 API 5083 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) { 5084 return ::WSAStartup(wVersionRequested, lpWSAData); 5085 } 5086 5087 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) { 5088 return ::gethostbyname(name); 5089 } 5090 5091 inline BOOL os::WinSock2Dll::WinSock2Available() { 5092 return true; 5093 } 5094 5095 // Advapi API 5096 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle, 5097 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, 5098 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) { 5099 return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState, 5100 BufferLength, PreviousState, ReturnLength); 5101 } 5102 5103 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, 5104 PHANDLE TokenHandle) { 5105 return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle); 5106 } 5107 5108 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) { 5109 return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid); 5110 } 5111 5112 inline BOOL os::Advapi32Dll::AdvapiAvailable() { 5113 return true; 5114 } 5115 5116 #else 5117 // Kernel32 API 5118 typedef BOOL (WINAPI* SwitchToThread_Fn)(void); 5119 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD); 5120 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32); 5121 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32); 5122 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO); 5123 5124 SwitchToThread_Fn os::Kernel32Dll::_SwitchToThread = NULL; 5125 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL; 5126 Module32First_Fn os::Kernel32Dll::_Module32First = NULL; 5127 Module32Next_Fn os::Kernel32Dll::_Module32Next = NULL; 5128 GetNativeSystemInfo_Fn os::Kernel32Dll::_GetNativeSystemInfo = NULL; 5129 5130 5131 void os::Kernel32Dll::initialize() { 5132 if (!initialized) { 5133 HMODULE handle = ::GetModuleHandle("Kernel32.dll"); 5134 assert(handle != NULL, "Just check"); 5135 5136 _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread"); 5137 _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn) 5138 ::GetProcAddress(handle, "CreateToolhelp32Snapshot"); 5139 _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First"); 5140 _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next"); 5141 _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo"); 5142 initializeCommon(); // resolve the functions that always need resolving 5143 5144 initialized = TRUE; 5145 } 5146 } 5147 5148 BOOL os::Kernel32Dll::SwitchToThread() { 5149 assert(initialized && _SwitchToThread != NULL, 5150 "SwitchToThreadAvailable() not yet called"); 5151 return _SwitchToThread(); 5152 } 5153 5154 5155 BOOL os::Kernel32Dll::SwitchToThreadAvailable() { 5156 if (!initialized) { 5157 initialize(); 5158 } 5159 return _SwitchToThread != NULL; 5160 } 5161 5162 // Help tools 5163 BOOL os::Kernel32Dll::HelpToolsAvailable() { 5164 if (!initialized) { 5165 initialize(); 5166 } 5167 return _CreateToolhelp32Snapshot != NULL && 5168 _Module32First != NULL && 5169 _Module32Next != NULL; 5170 } 5171 5172 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) { 5173 assert(initialized && _CreateToolhelp32Snapshot != NULL, 5174 "HelpToolsAvailable() not yet called"); 5175 5176 return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId); 5177 } 5178 5179 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) { 5180 assert(initialized && _Module32First != NULL, 5181 "HelpToolsAvailable() not yet called"); 5182 5183 return _Module32First(hSnapshot, lpme); 5184 } 5185 5186 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) { 5187 assert(initialized && _Module32Next != NULL, 5188 "HelpToolsAvailable() not yet called"); 5189 5190 return _Module32Next(hSnapshot, lpme); 5191 } 5192 5193 5194 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() { 5195 if (!initialized) { 5196 initialize(); 5197 } 5198 return _GetNativeSystemInfo != NULL; 5199 } 5200 5201 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) { 5202 assert(initialized && _GetNativeSystemInfo != NULL, 5203 "GetNativeSystemInfoAvailable() not yet called"); 5204 5205 _GetNativeSystemInfo(lpSystemInfo); 5206 } 5207 5208 5209 5210 // PSAPI API 5211 5212 5213 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD); 5214 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);; 5215 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD); 5216 5217 EnumProcessModules_Fn os::PSApiDll::_EnumProcessModules = NULL; 5218 GetModuleFileNameEx_Fn os::PSApiDll::_GetModuleFileNameEx = NULL; 5219 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL; 5220 BOOL os::PSApiDll::initialized = FALSE; 5221 5222 void os::PSApiDll::initialize() { 5223 if (!initialized) { 5224 HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0); 5225 if (handle != NULL) { 5226 _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle, 5227 "EnumProcessModules"); 5228 _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle, 5229 "GetModuleFileNameExA"); 5230 _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle, 5231 "GetModuleInformation"); 5232 } 5233 initialized = TRUE; 5234 } 5235 } 5236 5237 5238 5239 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) { 5240 assert(initialized && _EnumProcessModules != NULL, 5241 "PSApiAvailable() not yet called"); 5242 return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded); 5243 } 5244 5245 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) { 5246 assert(initialized && _GetModuleFileNameEx != NULL, 5247 "PSApiAvailable() not yet called"); 5248 return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize); 5249 } 5250 5251 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) { 5252 assert(initialized && _GetModuleInformation != NULL, 5253 "PSApiAvailable() not yet called"); 5254 return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb); 5255 } 5256 5257 BOOL os::PSApiDll::PSApiAvailable() { 5258 if (!initialized) { 5259 initialize(); 5260 } 5261 return _EnumProcessModules != NULL && 5262 _GetModuleFileNameEx != NULL && 5263 _GetModuleInformation != NULL; 5264 } 5265 5266 5267 // WinSock2 API 5268 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA); 5269 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...); 5270 5271 WSAStartup_Fn os::WinSock2Dll::_WSAStartup = NULL; 5272 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL; 5273 BOOL os::WinSock2Dll::initialized = FALSE; 5274 5275 void os::WinSock2Dll::initialize() { 5276 if (!initialized) { 5277 HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0); 5278 if (handle != NULL) { 5279 _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup"); 5280 _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname"); 5281 } 5282 initialized = TRUE; 5283 } 5284 } 5285 5286 5287 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) { 5288 assert(initialized && _WSAStartup != NULL, 5289 "WinSock2Available() not yet called"); 5290 return _WSAStartup(wVersionRequested, lpWSAData); 5291 } 5292 5293 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) { 5294 assert(initialized && _gethostbyname != NULL, 5295 "WinSock2Available() not yet called"); 5296 return _gethostbyname(name); 5297 } 5298 5299 BOOL os::WinSock2Dll::WinSock2Available() { 5300 if (!initialized) { 5301 initialize(); 5302 } 5303 return _WSAStartup != NULL && 5304 _gethostbyname != NULL; 5305 } 5306 5307 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD); 5308 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE); 5309 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID); 5310 5311 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL; 5312 OpenProcessToken_Fn os::Advapi32Dll::_OpenProcessToken = NULL; 5313 LookupPrivilegeValue_Fn os::Advapi32Dll::_LookupPrivilegeValue = NULL; 5314 BOOL os::Advapi32Dll::initialized = FALSE; 5315 5316 void os::Advapi32Dll::initialize() { 5317 if (!initialized) { 5318 HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0); 5319 if (handle != NULL) { 5320 _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle, 5321 "AdjustTokenPrivileges"); 5322 _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle, 5323 "OpenProcessToken"); 5324 _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle, 5325 "LookupPrivilegeValueA"); 5326 } 5327 initialized = TRUE; 5328 } 5329 } 5330 5331 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle, 5332 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, 5333 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) { 5334 assert(initialized && _AdjustTokenPrivileges != NULL, 5335 "AdvapiAvailable() not yet called"); 5336 return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState, 5337 BufferLength, PreviousState, ReturnLength); 5338 } 5339 5340 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, 5341 PHANDLE TokenHandle) { 5342 assert(initialized && _OpenProcessToken != NULL, 5343 "AdvapiAvailable() not yet called"); 5344 return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle); 5345 } 5346 5347 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) { 5348 assert(initialized && _LookupPrivilegeValue != NULL, 5349 "AdvapiAvailable() not yet called"); 5350 return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid); 5351 } 5352 5353 BOOL os::Advapi32Dll::AdvapiAvailable() { 5354 if (!initialized) { 5355 initialize(); 5356 } 5357 return _AdjustTokenPrivileges != NULL && 5358 _OpenProcessToken != NULL && 5359 _LookupPrivilegeValue != NULL; 5360 } 5361 5362 #endif 5363