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