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