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