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