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