Wed, 12 Jan 2011 13:59:18 -0800
7009828: Fix for 6938627 breaks visualvm monitoring when -Djava.io.tmpdir is defined
Summary: Change get_temp_directory() back to /tmp and %TEMP% like it always was and where the tools expect it to be.
Reviewed-by: phh, dcubed, kamg, alanb
1 /*
2 * CopyrighT (c) 1997, 2010, 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 */
25 #ifdef _WIN64
26 // Must be at least Windows 2000 or XP to use VectoredExceptions
27 #define _WIN32_WINNT 0x500
28 #endif
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
81 #ifdef _DEBUG
82 #include <crtdbg.h>
83 #endif
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>
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
102 /* for enumerating dll libraries */
103 #include <tlhelp32.h>
104 #include <vdmdbg.h>
106 // for timer info max values which include all bits
107 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
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
114 static HANDLE main_process;
115 static HANDLE main_thread;
116 static int main_thread_id;
118 static FILETIME process_creation_time;
119 static FILETIME process_exit_time;
120 static FILETIME process_user_time;
121 static FILETIME process_kernel_time;
123 #ifdef _WIN64
124 PVOID topLevelVectoredExceptionHandler = NULL;
125 #endif
127 #ifdef _M_IA64
128 #define __CPU__ ia64
129 #elif _M_AMD64
130 #define __CPU__ amd64
131 #else
132 #define __CPU__ i486
133 #endif
135 // save DLL module handle, used by GetModuleFileName
137 HINSTANCE vm_lib_handle;
138 static int getLastErrorString(char *buf, size_t len);
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 }
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 }
171 // Implementation of os
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 }
179 // No setuid programs under Windows.
180 bool os::have_special_privileges() {
181 return false;
182 }
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 }
192 #ifndef _WIN64
193 // previous UnhandledExceptionFilter, if there is one
194 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
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];
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 }
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);
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);
234 if (!set_boot_path('\\', ';'))
235 return;
236 }
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 */
253 char *library_path;
254 char tmp[MAX_PATH];
255 char *path_str = ::getenv("PATH");
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);
260 library_path[0] = '\0';
262 GetModuleFileName(NULL, tmp, sizeof(tmp));
263 *(strrchr(tmp, '\\')) = '\0';
264 strcat(library_path, tmp);
266 strcat(library_path, ";.");
268 GetWindowsDirectory(tmp, sizeof(tmp));
269 strcat(library_path, ";");
270 strcat(library_path, tmp);
271 strcat(library_path, PACKAGE_DIR BIN_DIR);
273 GetSystemDirectory(tmp, sizeof(tmp));
274 strcat(library_path, ";");
275 strcat(library_path, tmp);
277 GetWindowsDirectory(tmp, sizeof(tmp));
278 strcat(library_path, ";");
279 strcat(library_path, tmp);
281 if (path_str) {
282 strcat(library_path, ";");
283 strcat(library_path, path_str);
284 }
286 Arguments::set_library_path(library_path);
287 FREE_C_HEAP_ARRAY(char, library_path);
288 }
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
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 }
313 #ifndef _WIN64
314 // set our UnhandledExceptionFilter and save any previous one
315 prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);
316 #endif
318 // Done
319 return;
320 }
322 void os::breakpoint() {
323 DebugBreak();
324 }
326 // Invoked from the BREAKPOINT Macro
327 extern "C" void breakpoint() {
328 os::breakpoint();
329 }
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.
335 address os::current_stack_pointer() {
336 int dummy;
337 address sp = (address)&dummy;
338 return sp;
339 }
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.
347 address os::current_stack_base() {
348 MEMORY_BASIC_INFORMATION minfo;
349 address stack_bottom;
350 size_t stack_size;
352 VirtualQuery(&minfo, &minfo, sizeof(minfo));
353 stack_bottom = (address)minfo.AllocationBase;
354 stack_size = minfo.RegionSize;
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 }
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 }
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 }
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 }
391 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
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);
404 OSThread* osthr = thread->osthread();
405 assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
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 }
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 }
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 }
438 return 0;
439 }
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;
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);
454 // Store info on the Win32 thread into the OSThread
455 osthread->set_thread_handle(thread_handle);
456 osthread->set_thread_id(thread_id);
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 }
465 // Initial thread state is INITIALIZED, not SUSPENDED
466 osthread->set_state(INITIALIZED);
468 return osthread;
469 }
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 }
487 // Initial thread state is RUNNABLE
488 osthread->set_state(RUNNABLE);
490 thread->set_osthread(osthread);
491 return true;
492 }
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 }
505 // The primordial thread is runnable from the start)
506 _starting_thread->set_state(RUNNABLE);
508 thread->set_osthread(_starting_thread);
509 return true;
510 }
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;
516 // Allocate the OSThread object
517 OSThread* osthread = new OSThread(NULL, NULL);
518 if (osthread == NULL) {
519 return false;
520 }
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);
531 thread->set_osthread(osthread);
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 }
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.
576 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
577 #define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000)
578 #endif
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 }
606 Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
608 // Store info on the Win32 thread into the OSThread
609 osthread->set_thread_handle(thread_handle);
610 osthread->set_thread_id(thread_id);
612 // Initial thread state is INITIALIZED, not SUSPENDED
613 osthread->set_state(INITIALIZED);
615 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
616 return true;
617 }
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 }
629 static int has_performance_count = 0;
630 static jlong first_filetime;
631 static jlong initial_performance_count;
632 static jlong performance_frequency;
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 }
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 }
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 }
666 julong os::available_memory() {
667 return win32::available_memory();
668 }
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);
677 return (julong)ms.ullAvailPhys;
678 }
680 julong os::physical_memory() {
681 return win32::physical_memory();
682 }
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 }
693 // VC6 lacks DWORD_PTR
694 #if _MSC_VER < 1300
695 typedef UINT_PTR DWORD_PTR;
696 #endif
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 }
716 bool os::distribute_processes(uint length, uint* distribution) {
717 // Not yet implemented.
718 return false;
719 }
721 bool os::bind_to_processor(uint processor_id) {
722 // Not yet implemented.
723 return false;
724 }
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 }
742 double os::elapsedTime() {
743 return (double) elapsed_counter() / (double) elapsed_frequency();
744 }
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
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;
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;
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
788 jlong windows_to_java_time(FILETIME wt) {
789 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
790 return (a - offset()) / 10000;
791 }
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 }
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).
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 }
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 }
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 }
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;
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 }
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 }
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 }
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 }
903 void os::shutdown() {
905 // allow PerfMemory to attempt cleanup of any persistent resources
906 perfMemory_exit();
908 // flush buffered output, finish log files
909 ostream_abort();
911 // Check for abort hook
912 abort_hook_t abort_hook = Arguments::abort_hook();
913 if (abort_hook != NULL) {
914 abort_hook();
915 }
916 }
918 void os::abort(bool dump_core)
919 {
920 os::shutdown();
921 // no core dump on Windows
922 ::exit(1);
923 }
925 // Die immediately, no exit hook, no abort hook, no cleanup.
926 void os::die() {
927 _exit(-1);
928 }
930 // Directory routines copied from src/win32/native/java/io/dirent_md.c
931 // * dirent_md.c 1.15 00/02/02
932 //
933 // The declarations for DIR and struct dirent are in jvm_win32.h.
935 /* Caller must have already run dirname through JVM_NativePath, which removes
936 duplicate slashes and converts all instances of '/' into '\\'. */
938 DIR *
939 os::opendir(const char *dirname)
940 {
941 assert(dirname != NULL, "just checking"); // hotspot change
942 DIR *dirp = (DIR *)malloc(sizeof(DIR));
943 DWORD fattr; // hotspot change
944 char alt_dirname[4] = { 0, 0, 0, 0 };
946 if (dirp == 0) {
947 errno = ENOMEM;
948 return 0;
949 }
951 /*
952 * Win32 accepts "\" in its POSIX stat(), but refuses to treat it
953 * as a directory in FindFirstFile(). We detect this case here and
954 * prepend the current drive name.
955 */
956 if (dirname[1] == '\0' && dirname[0] == '\\') {
957 alt_dirname[0] = _getdrive() + 'A' - 1;
958 alt_dirname[1] = ':';
959 alt_dirname[2] = '\\';
960 alt_dirname[3] = '\0';
961 dirname = alt_dirname;
962 }
964 dirp->path = (char *)malloc(strlen(dirname) + 5);
965 if (dirp->path == 0) {
966 free(dirp);
967 errno = ENOMEM;
968 return 0;
969 }
970 strcpy(dirp->path, dirname);
972 fattr = GetFileAttributes(dirp->path);
973 if (fattr == 0xffffffff) {
974 free(dirp->path);
975 free(dirp);
976 errno = ENOENT;
977 return 0;
978 } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
979 free(dirp->path);
980 free(dirp);
981 errno = ENOTDIR;
982 return 0;
983 }
985 /* Append "*.*", or possibly "\\*.*", to path */
986 if (dirp->path[1] == ':'
987 && (dirp->path[2] == '\0'
988 || (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
989 /* No '\\' needed for cases like "Z:" or "Z:\" */
990 strcat(dirp->path, "*.*");
991 } else {
992 strcat(dirp->path, "\\*.*");
993 }
995 dirp->handle = FindFirstFile(dirp->path, &dirp->find_data);
996 if (dirp->handle == INVALID_HANDLE_VALUE) {
997 if (GetLastError() != ERROR_FILE_NOT_FOUND) {
998 free(dirp->path);
999 free(dirp);
1000 errno = EACCES;
1001 return 0;
1002 }
1003 }
1004 return dirp;
1005 }
1007 /* parameter dbuf unused on Windows */
1009 struct dirent *
1010 os::readdir(DIR *dirp, dirent *dbuf)
1011 {
1012 assert(dirp != NULL, "just checking"); // hotspot change
1013 if (dirp->handle == INVALID_HANDLE_VALUE) {
1014 return 0;
1015 }
1017 strcpy(dirp->dirent.d_name, dirp->find_data.cFileName);
1019 if (!FindNextFile(dirp->handle, &dirp->find_data)) {
1020 if (GetLastError() == ERROR_INVALID_HANDLE) {
1021 errno = EBADF;
1022 return 0;
1023 }
1024 FindClose(dirp->handle);
1025 dirp->handle = INVALID_HANDLE_VALUE;
1026 }
1028 return &dirp->dirent;
1029 }
1031 int
1032 os::closedir(DIR *dirp)
1033 {
1034 assert(dirp != NULL, "just checking"); // hotspot change
1035 if (dirp->handle != INVALID_HANDLE_VALUE) {
1036 if (!FindClose(dirp->handle)) {
1037 errno = EBADF;
1038 return -1;
1039 }
1040 dirp->handle = INVALID_HANDLE_VALUE;
1041 }
1042 free(dirp->path);
1043 free(dirp);
1044 return 0;
1045 }
1047 // This must be hard coded because it's the system's temporary
1048 // directory not the java application's temp directory, ala java.io.tmpdir.
1049 const char* os::get_temp_directory() {
1050 static char path_buf[MAX_PATH];
1051 if (GetTempPath(MAX_PATH, path_buf)>0)
1052 return path_buf;
1053 else{
1054 path_buf[0]='\0';
1055 return path_buf;
1056 }
1057 }
1059 static bool file_exists(const char* filename) {
1060 if (filename == NULL || strlen(filename) == 0) {
1061 return false;
1062 }
1063 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
1064 }
1066 void os::dll_build_name(char *buffer, size_t buflen,
1067 const char* pname, const char* fname) {
1068 const size_t pnamelen = pname ? strlen(pname) : 0;
1069 const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
1071 // Quietly truncates on buffer overflow. Should be an error.
1072 if (pnamelen + strlen(fname) + 10 > buflen) {
1073 *buffer = '\0';
1074 return;
1075 }
1077 if (pnamelen == 0) {
1078 jio_snprintf(buffer, buflen, "%s.dll", fname);
1079 } else if (c == ':' || c == '\\') {
1080 jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname);
1081 } else if (strchr(pname, *os::path_separator()) != NULL) {
1082 int n;
1083 char** pelements = split_path(pname, &n);
1084 for (int i = 0 ; i < n ; i++) {
1085 char* path = pelements[i];
1086 // Really shouldn't be NULL, but check can't hurt
1087 size_t plen = (path == NULL) ? 0 : strlen(path);
1088 if (plen == 0) {
1089 continue; // skip the empty path values
1090 }
1091 const char lastchar = path[plen - 1];
1092 if (lastchar == ':' || lastchar == '\\') {
1093 jio_snprintf(buffer, buflen, "%s%s.dll", path, fname);
1094 } else {
1095 jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname);
1096 }
1097 if (file_exists(buffer)) {
1098 break;
1099 }
1100 }
1101 // release the storage
1102 for (int i = 0 ; i < n ; i++) {
1103 if (pelements[i] != NULL) {
1104 FREE_C_HEAP_ARRAY(char, pelements[i]);
1105 }
1106 }
1107 if (pelements != NULL) {
1108 FREE_C_HEAP_ARRAY(char*, pelements);
1109 }
1110 } else {
1111 jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname);
1112 }
1113 }
1115 // Needs to be in os specific directory because windows requires another
1116 // header file <direct.h>
1117 const char* os::get_current_directory(char *buf, int buflen) {
1118 return _getcwd(buf, buflen);
1119 }
1121 //-----------------------------------------------------------
1122 // Helper functions for fatal error handler
1124 // The following library functions are resolved dynamically at runtime:
1126 // PSAPI functions, for Windows NT, 2000, XP
1128 // psapi.h doesn't come with Visual Studio 6; it can be downloaded as Platform
1129 // SDK from Microsoft. Here are the definitions copied from psapi.h
1130 typedef struct _MODULEINFO {
1131 LPVOID lpBaseOfDll;
1132 DWORD SizeOfImage;
1133 LPVOID EntryPoint;
1134 } MODULEINFO, *LPMODULEINFO;
1136 static BOOL (WINAPI *_EnumProcessModules) ( HANDLE, HMODULE *, DWORD, LPDWORD );
1137 static DWORD (WINAPI *_GetModuleFileNameEx) ( HANDLE, HMODULE, LPTSTR, DWORD );
1138 static BOOL (WINAPI *_GetModuleInformation)( HANDLE, HMODULE, LPMODULEINFO, DWORD );
1140 // ToolHelp Functions, for Windows 95, 98 and ME
1142 static HANDLE(WINAPI *_CreateToolhelp32Snapshot)(DWORD,DWORD) ;
1143 static BOOL (WINAPI *_Module32First) (HANDLE,LPMODULEENTRY32) ;
1144 static BOOL (WINAPI *_Module32Next) (HANDLE,LPMODULEENTRY32) ;
1146 bool _has_psapi;
1147 bool _psapi_init = false;
1148 bool _has_toolhelp;
1150 static bool _init_psapi() {
1151 HINSTANCE psapi = LoadLibrary( "PSAPI.DLL" ) ;
1152 if( psapi == NULL ) return false ;
1154 _EnumProcessModules = CAST_TO_FN_PTR(
1155 BOOL(WINAPI *)(HANDLE, HMODULE *, DWORD, LPDWORD),
1156 GetProcAddress(psapi, "EnumProcessModules")) ;
1157 _GetModuleFileNameEx = CAST_TO_FN_PTR(
1158 DWORD (WINAPI *)(HANDLE, HMODULE, LPTSTR, DWORD),
1159 GetProcAddress(psapi, "GetModuleFileNameExA"));
1160 _GetModuleInformation = CAST_TO_FN_PTR(
1161 BOOL (WINAPI *)(HANDLE, HMODULE, LPMODULEINFO, DWORD),
1162 GetProcAddress(psapi, "GetModuleInformation"));
1164 _has_psapi = (_EnumProcessModules && _GetModuleFileNameEx && _GetModuleInformation);
1165 _psapi_init = true;
1166 return _has_psapi;
1167 }
1169 static bool _init_toolhelp() {
1170 HINSTANCE kernel32 = LoadLibrary("Kernel32.DLL") ;
1171 if (kernel32 == NULL) return false ;
1173 _CreateToolhelp32Snapshot = CAST_TO_FN_PTR(
1174 HANDLE(WINAPI *)(DWORD,DWORD),
1175 GetProcAddress(kernel32, "CreateToolhelp32Snapshot"));
1176 _Module32First = CAST_TO_FN_PTR(
1177 BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32),
1178 GetProcAddress(kernel32, "Module32First" ));
1179 _Module32Next = CAST_TO_FN_PTR(
1180 BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32),
1181 GetProcAddress(kernel32, "Module32Next" ));
1183 _has_toolhelp = (_CreateToolhelp32Snapshot && _Module32First && _Module32Next);
1184 return _has_toolhelp;
1185 }
1187 #ifdef _WIN64
1188 // Helper routine which returns true if address in
1189 // within the NTDLL address space.
1190 //
1191 static bool _addr_in_ntdll( address addr )
1192 {
1193 HMODULE hmod;
1194 MODULEINFO minfo;
1196 hmod = GetModuleHandle("NTDLL.DLL");
1197 if ( hmod == NULL ) return false;
1198 if ( !_GetModuleInformation( GetCurrentProcess(), hmod,
1199 &minfo, sizeof(MODULEINFO)) )
1200 return false;
1202 if ( (addr >= minfo.lpBaseOfDll) &&
1203 (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
1204 return true;
1205 else
1206 return false;
1207 }
1208 #endif
1211 // Enumerate all modules for a given process ID
1212 //
1213 // Notice that Windows 95/98/Me and Windows NT/2000/XP have
1214 // different API for doing this. We use PSAPI.DLL on NT based
1215 // Windows and ToolHelp on 95/98/Me.
1217 // Callback function that is called by enumerate_modules() on
1218 // every DLL module.
1219 // Input parameters:
1220 // int pid,
1221 // char* module_file_name,
1222 // address module_base_addr,
1223 // unsigned module_size,
1224 // void* param
1225 typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
1227 // enumerate_modules for Windows NT, using PSAPI
1228 static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
1229 {
1230 HANDLE hProcess ;
1232 # define MAX_NUM_MODULES 128
1233 HMODULE modules[MAX_NUM_MODULES];
1234 static char filename[ MAX_PATH ];
1235 int result = 0;
1237 if (!_has_psapi && (_psapi_init || !_init_psapi())) return 0;
1239 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1240 FALSE, pid ) ;
1241 if (hProcess == NULL) return 0;
1243 DWORD size_needed;
1244 if (!_EnumProcessModules(hProcess, modules,
1245 sizeof(modules), &size_needed)) {
1246 CloseHandle( hProcess );
1247 return 0;
1248 }
1250 // number of modules that are currently loaded
1251 int num_modules = size_needed / sizeof(HMODULE);
1253 for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1254 // Get Full pathname:
1255 if(!_GetModuleFileNameEx(hProcess, modules[i],
1256 filename, sizeof(filename))) {
1257 filename[0] = '\0';
1258 }
1260 MODULEINFO modinfo;
1261 if (!_GetModuleInformation(hProcess, modules[i],
1262 &modinfo, sizeof(modinfo))) {
1263 modinfo.lpBaseOfDll = NULL;
1264 modinfo.SizeOfImage = 0;
1265 }
1267 // Invoke callback function
1268 result = func(pid, filename, (address)modinfo.lpBaseOfDll,
1269 modinfo.SizeOfImage, param);
1270 if (result) break;
1271 }
1273 CloseHandle( hProcess ) ;
1274 return result;
1275 }
1278 // enumerate_modules for Windows 95/98/ME, using TOOLHELP
1279 static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
1280 {
1281 HANDLE hSnapShot ;
1282 static MODULEENTRY32 modentry ;
1283 int result = 0;
1285 if (!_has_toolhelp) return 0;
1287 // Get a handle to a Toolhelp snapshot of the system
1288 hSnapShot = _CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ;
1289 if( hSnapShot == INVALID_HANDLE_VALUE ) {
1290 return FALSE ;
1291 }
1293 // iterate through all modules
1294 modentry.dwSize = sizeof(MODULEENTRY32) ;
1295 bool not_done = _Module32First( hSnapShot, &modentry ) != 0;
1297 while( not_done ) {
1298 // invoke the callback
1299 result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
1300 modentry.modBaseSize, param);
1301 if (result) break;
1303 modentry.dwSize = sizeof(MODULEENTRY32) ;
1304 not_done = _Module32Next( hSnapShot, &modentry ) != 0;
1305 }
1307 CloseHandle(hSnapShot);
1308 return result;
1309 }
1311 int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param )
1312 {
1313 // Get current process ID if caller doesn't provide it.
1314 if (!pid) pid = os::current_process_id();
1316 if (os::win32::is_nt()) return _enumerate_modules_winnt (pid, func, param);
1317 else return _enumerate_modules_windows(pid, func, param);
1318 }
1320 struct _modinfo {
1321 address addr;
1322 char* full_path; // point to a char buffer
1323 int buflen; // size of the buffer
1324 address base_addr;
1325 };
1327 static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr,
1328 unsigned size, void * param) {
1329 struct _modinfo *pmod = (struct _modinfo *)param;
1330 if (!pmod) return -1;
1332 if (base_addr <= pmod->addr &&
1333 base_addr+size > pmod->addr) {
1334 // if a buffer is provided, copy path name to the buffer
1335 if (pmod->full_path) {
1336 jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
1337 }
1338 pmod->base_addr = base_addr;
1339 return 1;
1340 }
1341 return 0;
1342 }
1344 bool os::dll_address_to_library_name(address addr, char* buf,
1345 int buflen, int* offset) {
1346 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
1347 // return the full path to the DLL file, sometimes it returns path
1348 // to the corresponding PDB file (debug info); sometimes it only
1349 // returns partial path, which makes life painful.
1351 struct _modinfo mi;
1352 mi.addr = addr;
1353 mi.full_path = buf;
1354 mi.buflen = buflen;
1355 int pid = os::current_process_id();
1356 if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
1357 // buf already contains path name
1358 if (offset) *offset = addr - mi.base_addr;
1359 return true;
1360 } else {
1361 if (buf) buf[0] = '\0';
1362 if (offset) *offset = -1;
1363 return false;
1364 }
1365 }
1367 bool os::dll_address_to_function_name(address addr, char *buf,
1368 int buflen, int *offset) {
1369 if (Decoder::decode(addr, buf, buflen, offset) == Decoder::no_error) {
1370 return true;
1371 }
1372 if (offset != NULL) *offset = -1;
1373 if (buf != NULL) buf[0] = '\0';
1374 return false;
1375 }
1377 // save the start and end address of jvm.dll into param[0] and param[1]
1378 static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
1379 unsigned size, void * param) {
1380 if (!param) return -1;
1382 if (base_addr <= (address)_locate_jvm_dll &&
1383 base_addr+size > (address)_locate_jvm_dll) {
1384 ((address*)param)[0] = base_addr;
1385 ((address*)param)[1] = base_addr + size;
1386 return 1;
1387 }
1388 return 0;
1389 }
1391 address vm_lib_location[2]; // start and end address of jvm.dll
1393 // check if addr is inside jvm.dll
1394 bool os::address_is_in_vm(address addr) {
1395 if (!vm_lib_location[0] || !vm_lib_location[1]) {
1396 int pid = os::current_process_id();
1397 if (!enumerate_modules(pid, _locate_jvm_dll, (void *)vm_lib_location)) {
1398 assert(false, "Can't find jvm module.");
1399 return false;
1400 }
1401 }
1403 return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]);
1404 }
1406 // print module info; param is outputStream*
1407 static int _print_module(int pid, char* fname, address base,
1408 unsigned size, void* param) {
1409 if (!param) return -1;
1411 outputStream* st = (outputStream*)param;
1413 address end_addr = base + size;
1414 st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname);
1415 return 0;
1416 }
1418 // Loads .dll/.so and
1419 // in case of error it checks if .dll/.so was built for the
1420 // same architecture as Hotspot is running on
1421 void * os::dll_load(const char *name, char *ebuf, int ebuflen)
1422 {
1423 void * result = LoadLibrary(name);
1424 if (result != NULL)
1425 {
1426 return result;
1427 }
1429 long errcode = GetLastError();
1430 if (errcode == ERROR_MOD_NOT_FOUND) {
1431 strncpy(ebuf, "Can't find dependent libraries", ebuflen-1);
1432 ebuf[ebuflen-1]='\0';
1433 return NULL;
1434 }
1436 // Parsing dll below
1437 // If we can read dll-info and find that dll was built
1438 // for an architecture other than Hotspot is running in
1439 // - then print to buffer "DLL was built for a different architecture"
1440 // else call getLastErrorString to obtain system error message
1442 // Read system error message into ebuf
1443 // It may or may not be overwritten below (in the for loop and just above)
1444 getLastErrorString(ebuf, (size_t) ebuflen);
1445 ebuf[ebuflen-1]='\0';
1446 int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0);
1447 if (file_descriptor<0)
1448 {
1449 return NULL;
1450 }
1452 uint32_t signature_offset;
1453 uint16_t lib_arch=0;
1454 bool failed_to_get_lib_arch=
1455 (
1456 //Go to position 3c in the dll
1457 (os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0)
1458 ||
1459 // Read loacation of signature
1460 (sizeof(signature_offset)!=
1461 (os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset))))
1462 ||
1463 //Go to COFF File Header in dll
1464 //that is located after"signature" (4 bytes long)
1465 (os::seek_to_file_offset(file_descriptor,
1466 signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0)
1467 ||
1468 //Read field that contains code of architecture
1469 // that dll was build for
1470 (sizeof(lib_arch)!=
1471 (os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch))))
1472 );
1474 ::close(file_descriptor);
1475 if (failed_to_get_lib_arch)
1476 {
1477 // file i/o error - report getLastErrorString(...) msg
1478 return NULL;
1479 }
1481 typedef struct
1482 {
1483 uint16_t arch_code;
1484 char* arch_name;
1485 } arch_t;
1487 static const arch_t arch_array[]={
1488 {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"},
1489 {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"},
1490 {IMAGE_FILE_MACHINE_IA64, (char*)"IA 64"}
1491 };
1492 #if (defined _M_IA64)
1493 static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64;
1494 #elif (defined _M_AMD64)
1495 static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64;
1496 #elif (defined _M_IX86)
1497 static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386;
1498 #else
1499 #error Method os::dll_load requires that one of following \
1500 is defined :_M_IA64,_M_AMD64 or _M_IX86
1501 #endif
1504 // Obtain a string for printf operation
1505 // lib_arch_str shall contain string what platform this .dll was built for
1506 // running_arch_str shall string contain what platform Hotspot was built for
1507 char *running_arch_str=NULL,*lib_arch_str=NULL;
1508 for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++)
1509 {
1510 if (lib_arch==arch_array[i].arch_code)
1511 lib_arch_str=arch_array[i].arch_name;
1512 if (running_arch==arch_array[i].arch_code)
1513 running_arch_str=arch_array[i].arch_name;
1514 }
1516 assert(running_arch_str,
1517 "Didn't find runing architecture code in arch_array");
1519 // If the architure is right
1520 // but some other error took place - report getLastErrorString(...) msg
1521 if (lib_arch == running_arch)
1522 {
1523 return NULL;
1524 }
1526 if (lib_arch_str!=NULL)
1527 {
1528 ::_snprintf(ebuf, ebuflen-1,
1529 "Can't load %s-bit .dll on a %s-bit platform",
1530 lib_arch_str,running_arch_str);
1531 }
1532 else
1533 {
1534 // don't know what architecture this dll was build for
1535 ::_snprintf(ebuf, ebuflen-1,
1536 "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
1537 lib_arch,running_arch_str);
1538 }
1540 return NULL;
1541 }
1544 void os::print_dll_info(outputStream *st) {
1545 int pid = os::current_process_id();
1546 st->print_cr("Dynamic libraries:");
1547 enumerate_modules(pid, _print_module, (void *)st);
1548 }
1550 // function pointer to Windows API "GetNativeSystemInfo".
1551 typedef void (WINAPI *GetNativeSystemInfo_func_type)(LPSYSTEM_INFO);
1552 static GetNativeSystemInfo_func_type _GetNativeSystemInfo;
1554 void os::print_os_info(outputStream* st) {
1555 st->print("OS:");
1557 OSVERSIONINFOEX osvi;
1558 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1559 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1561 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1562 st->print_cr("N/A");
1563 return;
1564 }
1566 int os_vers = osvi.dwMajorVersion * 1000 + osvi.dwMinorVersion;
1567 if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1568 switch (os_vers) {
1569 case 3051: st->print(" Windows NT 3.51"); break;
1570 case 4000: st->print(" Windows NT 4.0"); break;
1571 case 5000: st->print(" Windows 2000"); break;
1572 case 5001: st->print(" Windows XP"); break;
1573 case 5002:
1574 case 6000:
1575 case 6001: {
1576 // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1577 // find out whether we are running on 64 bit processor or not.
1578 SYSTEM_INFO si;
1579 ZeroMemory(&si, sizeof(SYSTEM_INFO));
1580 // Check to see if _GetNativeSystemInfo has been initialized.
1581 if (_GetNativeSystemInfo == NULL) {
1582 HMODULE hKernel32 = GetModuleHandle(TEXT("kernel32.dll"));
1583 _GetNativeSystemInfo =
1584 CAST_TO_FN_PTR(GetNativeSystemInfo_func_type,
1585 GetProcAddress(hKernel32,
1586 "GetNativeSystemInfo"));
1587 if (_GetNativeSystemInfo == NULL)
1588 GetSystemInfo(&si);
1589 } else {
1590 _GetNativeSystemInfo(&si);
1591 }
1592 if (os_vers == 5002) {
1593 if (osvi.wProductType == VER_NT_WORKSTATION &&
1594 si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1595 st->print(" Windows XP x64 Edition");
1596 else
1597 st->print(" Windows Server 2003 family");
1598 } else if (os_vers == 6000) {
1599 if (osvi.wProductType == VER_NT_WORKSTATION)
1600 st->print(" Windows Vista");
1601 else
1602 st->print(" Windows Server 2008");
1603 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1604 st->print(" , 64 bit");
1605 } else if (os_vers == 6001) {
1606 if (osvi.wProductType == VER_NT_WORKSTATION) {
1607 st->print(" Windows 7");
1608 } else {
1609 // Unrecognized windows, print out its major and minor versions
1610 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1611 }
1612 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1613 st->print(" , 64 bit");
1614 } else { // future os
1615 // Unrecognized windows, print out its major and minor versions
1616 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1617 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
1618 st->print(" , 64 bit");
1619 }
1620 break;
1621 }
1622 default: // future windows, print out its major and minor versions
1623 st->print(" Windows NT %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1624 }
1625 } else {
1626 switch (os_vers) {
1627 case 4000: st->print(" Windows 95"); break;
1628 case 4010: st->print(" Windows 98"); break;
1629 case 4090: st->print(" Windows Me"); break;
1630 default: // future windows, print out its major and minor versions
1631 st->print(" Windows %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
1632 }
1633 }
1634 st->print(" Build %d", osvi.dwBuildNumber);
1635 st->print(" %s", osvi.szCSDVersion); // service pack
1636 st->cr();
1637 }
1639 void os::print_memory_info(outputStream* st) {
1640 st->print("Memory:");
1641 st->print(" %dk page", os::vm_page_size()>>10);
1643 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1644 // value if total memory is larger than 4GB
1645 MEMORYSTATUSEX ms;
1646 ms.dwLength = sizeof(ms);
1647 GlobalMemoryStatusEx(&ms);
1649 st->print(", physical %uk", os::physical_memory() >> 10);
1650 st->print("(%uk free)", os::available_memory() >> 10);
1652 st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1653 st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1654 st->cr();
1655 }
1657 void os::print_siginfo(outputStream *st, void *siginfo) {
1658 EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo;
1659 st->print("siginfo:");
1660 st->print(" ExceptionCode=0x%x", er->ExceptionCode);
1662 if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1663 er->NumberParameters >= 2) {
1664 switch (er->ExceptionInformation[0]) {
1665 case 0: st->print(", reading address"); break;
1666 case 1: st->print(", writing address"); break;
1667 default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1668 er->ExceptionInformation[0]);
1669 }
1670 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1671 } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
1672 er->NumberParameters >= 2 && UseSharedSpaces) {
1673 FileMapInfo* mapinfo = FileMapInfo::current_info();
1674 if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) {
1675 st->print("\n\nError accessing class data sharing archive." \
1676 " Mapped file inaccessible during execution, " \
1677 " possible disk/network problem.");
1678 }
1679 } else {
1680 int num = er->NumberParameters;
1681 if (num > 0) {
1682 st->print(", ExceptionInformation=");
1683 for (int i = 0; i < num; i++) {
1684 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1685 }
1686 }
1687 }
1688 st->cr();
1689 }
1691 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1692 // do nothing
1693 }
1695 static char saved_jvm_path[MAX_PATH] = {0};
1697 // Find the full path to the current module, jvm.dll or jvm_g.dll
1698 void os::jvm_path(char *buf, jint buflen) {
1699 // Error checking.
1700 if (buflen < MAX_PATH) {
1701 assert(false, "must use a large-enough buffer");
1702 buf[0] = '\0';
1703 return;
1704 }
1705 // Lazy resolve the path to current module.
1706 if (saved_jvm_path[0] != 0) {
1707 strcpy(buf, saved_jvm_path);
1708 return;
1709 }
1711 buf[0] = '\0';
1712 if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {
1713 // Support for the gamma launcher. Check for an
1714 // JAVA_HOME environment variable
1715 // and fix up the path so it looks like
1716 // libjvm.so is installed there (append a fake suffix
1717 // hotspot/libjvm.so).
1718 char* java_home_var = ::getenv("JAVA_HOME");
1719 if (java_home_var != NULL && java_home_var[0] != 0) {
1721 strncpy(buf, java_home_var, buflen);
1723 // determine if this is a legacy image or modules image
1724 // modules image doesn't have "jre" subdirectory
1725 size_t len = strlen(buf);
1726 char* jrebin_p = buf + len;
1727 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1728 if (0 != _access(buf, 0)) {
1729 jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1730 }
1731 len = strlen(buf);
1732 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1733 }
1734 }
1736 if(buf[0] == '\0') {
1737 GetModuleFileName(vm_lib_handle, buf, buflen);
1738 }
1739 strcpy(saved_jvm_path, buf);
1740 }
1743 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1744 #ifndef _WIN64
1745 st->print("_");
1746 #endif
1747 }
1750 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1751 #ifndef _WIN64
1752 st->print("@%d", args_size * sizeof(int));
1753 #endif
1754 }
1756 // This method is a copy of JDK's sysGetLastErrorString
1757 // from src/windows/hpi/src/system_md.c
1759 size_t os::lasterror(char *buf, size_t len) {
1760 long errval;
1762 if ((errval = GetLastError()) != 0) {
1763 /* DOS error */
1764 int n = (int)FormatMessage(
1765 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1766 NULL,
1767 errval,
1768 0,
1769 buf,
1770 (DWORD)len,
1771 NULL);
1772 if (n > 3) {
1773 /* Drop final '.', CR, LF */
1774 if (buf[n - 1] == '\n') n--;
1775 if (buf[n - 1] == '\r') n--;
1776 if (buf[n - 1] == '.') n--;
1777 buf[n] = '\0';
1778 }
1779 return n;
1780 }
1782 if (errno != 0) {
1783 /* C runtime error that has no corresponding DOS error code */
1784 const char *s = strerror(errno);
1785 size_t n = strlen(s);
1786 if (n >= len) n = len - 1;
1787 strncpy(buf, s, n);
1788 buf[n] = '\0';
1789 return n;
1790 }
1791 return 0;
1792 }
1794 // sun.misc.Signal
1795 // NOTE that this is a workaround for an apparent kernel bug where if
1796 // a signal handler for SIGBREAK is installed then that signal handler
1797 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1798 // See bug 4416763.
1799 static void (*sigbreakHandler)(int) = NULL;
1801 static void UserHandler(int sig, void *siginfo, void *context) {
1802 os::signal_notify(sig);
1803 // We need to reinstate the signal handler each time...
1804 os::signal(sig, (void*)UserHandler);
1805 }
1807 void* os::user_handler() {
1808 return (void*) UserHandler;
1809 }
1811 void* os::signal(int signal_number, void* handler) {
1812 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1813 void (*oldHandler)(int) = sigbreakHandler;
1814 sigbreakHandler = (void (*)(int)) handler;
1815 return (void*) oldHandler;
1816 } else {
1817 return (void*)::signal(signal_number, (void (*)(int))handler);
1818 }
1819 }
1821 void os::signal_raise(int signal_number) {
1822 raise(signal_number);
1823 }
1825 // The Win32 C runtime library maps all console control events other than ^C
1826 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1827 // logoff, and shutdown events. We therefore install our own console handler
1828 // that raises SIGTERM for the latter cases.
1829 //
1830 static BOOL WINAPI consoleHandler(DWORD event) {
1831 switch(event) {
1832 case CTRL_C_EVENT:
1833 if (is_error_reported()) {
1834 // Ctrl-C is pressed during error reporting, likely because the error
1835 // handler fails to abort. Let VM die immediately.
1836 os::die();
1837 }
1839 os::signal_raise(SIGINT);
1840 return TRUE;
1841 break;
1842 case CTRL_BREAK_EVENT:
1843 if (sigbreakHandler != NULL) {
1844 (*sigbreakHandler)(SIGBREAK);
1845 }
1846 return TRUE;
1847 break;
1848 case CTRL_CLOSE_EVENT:
1849 case CTRL_LOGOFF_EVENT:
1850 case CTRL_SHUTDOWN_EVENT:
1851 os::signal_raise(SIGTERM);
1852 return TRUE;
1853 break;
1854 default:
1855 break;
1856 }
1857 return FALSE;
1858 }
1860 /*
1861 * The following code is moved from os.cpp for making this
1862 * code platform specific, which it is by its very nature.
1863 */
1865 // Return maximum OS signal used + 1 for internal use only
1866 // Used as exit signal for signal_thread
1867 int os::sigexitnum_pd(){
1868 return NSIG;
1869 }
1871 // a counter for each possible signal value, including signal_thread exit signal
1872 static volatile jint pending_signals[NSIG+1] = { 0 };
1873 static HANDLE sig_sem;
1875 void os::signal_init_pd() {
1876 // Initialize signal structures
1877 memset((void*)pending_signals, 0, sizeof(pending_signals));
1879 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
1881 // Programs embedding the VM do not want it to attempt to receive
1882 // events like CTRL_LOGOFF_EVENT, which are used to implement the
1883 // shutdown hooks mechanism introduced in 1.3. For example, when
1884 // the VM is run as part of a Windows NT service (i.e., a servlet
1885 // engine in a web server), the correct behavior is for any console
1886 // control handler to return FALSE, not TRUE, because the OS's
1887 // "final" handler for such events allows the process to continue if
1888 // it is a service (while terminating it if it is not a service).
1889 // To make this behavior uniform and the mechanism simpler, we
1890 // completely disable the VM's usage of these console events if -Xrs
1891 // (=ReduceSignalUsage) is specified. This means, for example, that
1892 // the CTRL-BREAK thread dump mechanism is also disabled in this
1893 // case. See bugs 4323062, 4345157, and related bugs.
1895 if (!ReduceSignalUsage) {
1896 // Add a CTRL-C handler
1897 SetConsoleCtrlHandler(consoleHandler, TRUE);
1898 }
1899 }
1901 void os::signal_notify(int signal_number) {
1902 BOOL ret;
1904 Atomic::inc(&pending_signals[signal_number]);
1905 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1906 assert(ret != 0, "ReleaseSemaphore() failed");
1907 }
1909 static int check_pending_signals(bool wait_for_signal) {
1910 DWORD ret;
1911 while (true) {
1912 for (int i = 0; i < NSIG + 1; i++) {
1913 jint n = pending_signals[i];
1914 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1915 return i;
1916 }
1917 }
1918 if (!wait_for_signal) {
1919 return -1;
1920 }
1922 JavaThread *thread = JavaThread::current();
1924 ThreadBlockInVM tbivm(thread);
1926 bool threadIsSuspended;
1927 do {
1928 thread->set_suspend_equivalent();
1929 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1930 ret = ::WaitForSingleObject(sig_sem, INFINITE);
1931 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
1933 // were we externally suspended while we were waiting?
1934 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1935 if (threadIsSuspended) {
1936 //
1937 // The semaphore has been incremented, but while we were waiting
1938 // another thread suspended us. We don't want to continue running
1939 // while suspended because that would surprise the thread that
1940 // suspended us.
1941 //
1942 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1943 assert(ret != 0, "ReleaseSemaphore() failed");
1945 thread->java_suspend_self();
1946 }
1947 } while (threadIsSuspended);
1948 }
1949 }
1951 int os::signal_lookup() {
1952 return check_pending_signals(false);
1953 }
1955 int os::signal_wait() {
1956 return check_pending_signals(true);
1957 }
1959 // Implicit OS exception handling
1961 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
1962 JavaThread* thread = JavaThread::current();
1963 // Save pc in thread
1964 #ifdef _M_IA64
1965 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
1966 // Set pc to handler
1967 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
1968 #elif _M_AMD64
1969 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
1970 // Set pc to handler
1971 exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
1972 #else
1973 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
1974 // Set pc to handler
1975 exceptionInfo->ContextRecord->Eip = (LONG)handler;
1976 #endif
1978 // Continue the execution
1979 return EXCEPTION_CONTINUE_EXECUTION;
1980 }
1983 // Used for PostMortemDump
1984 extern "C" void safepoints();
1985 extern "C" void find(int x);
1986 extern "C" void events();
1988 // According to Windows API documentation, an illegal instruction sequence should generate
1989 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
1990 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
1991 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
1993 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
1995 // From "Execution Protection in the Windows Operating System" draft 0.35
1996 // Once a system header becomes available, the "real" define should be
1997 // included or copied here.
1998 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2000 #define def_excpt(val) #val, val
2002 struct siglabel {
2003 char *name;
2004 int number;
2005 };
2007 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2008 // C++ compiler contain this error code. Because this is a compiler-generated
2009 // error, the code is not listed in the Win32 API header files.
2010 // The code is actually a cryptic mnemonic device, with the initial "E"
2011 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2012 // ASCII values of "msc".
2014 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363
2017 struct siglabel exceptlabels[] = {
2018 def_excpt(EXCEPTION_ACCESS_VIOLATION),
2019 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2020 def_excpt(EXCEPTION_BREAKPOINT),
2021 def_excpt(EXCEPTION_SINGLE_STEP),
2022 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2023 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2024 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2025 def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2026 def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2027 def_excpt(EXCEPTION_FLT_OVERFLOW),
2028 def_excpt(EXCEPTION_FLT_STACK_CHECK),
2029 def_excpt(EXCEPTION_FLT_UNDERFLOW),
2030 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2031 def_excpt(EXCEPTION_INT_OVERFLOW),
2032 def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2033 def_excpt(EXCEPTION_IN_PAGE_ERROR),
2034 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2035 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2036 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2037 def_excpt(EXCEPTION_STACK_OVERFLOW),
2038 def_excpt(EXCEPTION_INVALID_DISPOSITION),
2039 def_excpt(EXCEPTION_GUARD_PAGE),
2040 def_excpt(EXCEPTION_INVALID_HANDLE),
2041 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2042 NULL, 0
2043 };
2045 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2046 for (int i = 0; exceptlabels[i].name != NULL; i++) {
2047 if (exceptlabels[i].number == exception_code) {
2048 jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2049 return buf;
2050 }
2051 }
2053 return NULL;
2054 }
2056 //-----------------------------------------------------------------------------
2057 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2058 // handle exception caused by idiv; should only happen for -MinInt/-1
2059 // (division by zero is handled explicitly)
2060 #ifdef _M_IA64
2061 assert(0, "Fix Handle_IDiv_Exception");
2062 #elif _M_AMD64
2063 PCONTEXT ctx = exceptionInfo->ContextRecord;
2064 address pc = (address)ctx->Rip;
2065 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2066 assert(pc[0] == 0xF7, "not an idiv opcode");
2067 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2068 assert(ctx->Rax == min_jint, "unexpected idiv exception");
2069 // set correct result values and continue after idiv instruction
2070 ctx->Rip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2071 ctx->Rax = (DWORD)min_jint; // result
2072 ctx->Rdx = (DWORD)0; // remainder
2073 // Continue the execution
2074 #else
2075 PCONTEXT ctx = exceptionInfo->ContextRecord;
2076 address pc = (address)ctx->Eip;
2077 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2078 assert(pc[0] == 0xF7, "not an idiv opcode");
2079 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2080 assert(ctx->Eax == min_jint, "unexpected idiv exception");
2081 // set correct result values and continue after idiv instruction
2082 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2083 ctx->Eax = (DWORD)min_jint; // result
2084 ctx->Edx = (DWORD)0; // remainder
2085 // Continue the execution
2086 #endif
2087 return EXCEPTION_CONTINUE_EXECUTION;
2088 }
2090 #ifndef _WIN64
2091 //-----------------------------------------------------------------------------
2092 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2093 // handle exception caused by native method modifying control word
2094 PCONTEXT ctx = exceptionInfo->ContextRecord;
2095 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2097 switch (exception_code) {
2098 case EXCEPTION_FLT_DENORMAL_OPERAND:
2099 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2100 case EXCEPTION_FLT_INEXACT_RESULT:
2101 case EXCEPTION_FLT_INVALID_OPERATION:
2102 case EXCEPTION_FLT_OVERFLOW:
2103 case EXCEPTION_FLT_STACK_CHECK:
2104 case EXCEPTION_FLT_UNDERFLOW:
2105 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2106 if (fp_control_word != ctx->FloatSave.ControlWord) {
2107 // Restore FPCW and mask out FLT exceptions
2108 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2109 // Mask out pending FLT exceptions
2110 ctx->FloatSave.StatusWord &= 0xffffff00;
2111 return EXCEPTION_CONTINUE_EXECUTION;
2112 }
2113 }
2115 if (prev_uef_handler != NULL) {
2116 // We didn't handle this exception so pass it to the previous
2117 // UnhandledExceptionFilter.
2118 return (prev_uef_handler)(exceptionInfo);
2119 }
2121 return EXCEPTION_CONTINUE_SEARCH;
2122 }
2123 #else //_WIN64
2124 /*
2125 On Windows, the mxcsr control bits are non-volatile across calls
2126 See also CR 6192333
2127 If EXCEPTION_FLT_* happened after some native method modified
2128 mxcsr - it is not a jvm fault.
2129 However should we decide to restore of mxcsr after a faulty
2130 native method we can uncomment following code
2131 jint MxCsr = INITIAL_MXCSR;
2132 // we can't use StubRoutines::addr_mxcsr_std()
2133 // because in Win64 mxcsr is not saved there
2134 if (MxCsr != ctx->MxCsr) {
2135 ctx->MxCsr = MxCsr;
2136 return EXCEPTION_CONTINUE_EXECUTION;
2137 }
2139 */
2140 #endif //_WIN64
2143 // Fatal error reporting is single threaded so we can make this a
2144 // static and preallocated. If it's more than MAX_PATH silently ignore
2145 // it.
2146 static char saved_error_file[MAX_PATH] = {0};
2148 void os::set_error_file(const char *logfile) {
2149 if (strlen(logfile) <= MAX_PATH) {
2150 strncpy(saved_error_file, logfile, MAX_PATH);
2151 }
2152 }
2154 static inline void report_error(Thread* t, DWORD exception_code,
2155 address addr, void* siginfo, void* context) {
2156 VMError err(t, exception_code, addr, siginfo, context);
2157 err.report_and_die();
2159 // If UseOsErrorReporting, this will return here and save the error file
2160 // somewhere where we can find it in the minidump.
2161 }
2163 //-----------------------------------------------------------------------------
2164 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2165 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2166 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2167 #ifdef _M_IA64
2168 address pc = (address) exceptionInfo->ContextRecord->StIIP;
2169 #elif _M_AMD64
2170 address pc = (address) exceptionInfo->ContextRecord->Rip;
2171 #else
2172 address pc = (address) exceptionInfo->ContextRecord->Eip;
2173 #endif
2174 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady
2176 #ifndef _WIN64
2177 // Execution protection violation - win32 running on AMD64 only
2178 // Handled first to avoid misdiagnosis as a "normal" access violation;
2179 // This is safe to do because we have a new/unique ExceptionInformation
2180 // code for this condition.
2181 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2182 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2183 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2184 address addr = (address) exceptionRecord->ExceptionInformation[1];
2186 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2187 int page_size = os::vm_page_size();
2189 // Make sure the pc and the faulting address are sane.
2190 //
2191 // If an instruction spans a page boundary, and the page containing
2192 // the beginning of the instruction is executable but the following
2193 // page is not, the pc and the faulting address might be slightly
2194 // different - we still want to unguard the 2nd page in this case.
2195 //
2196 // 15 bytes seems to be a (very) safe value for max instruction size.
2197 bool pc_is_near_addr =
2198 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2199 bool instr_spans_page_boundary =
2200 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2201 (intptr_t) page_size) > 0);
2203 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2204 static volatile address last_addr =
2205 (address) os::non_memory_address_word();
2207 // In conservative mode, don't unguard unless the address is in the VM
2208 if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2209 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2211 // Set memory to RWX and retry
2212 address page_start =
2213 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2214 bool res = os::protect_memory((char*) page_start, page_size,
2215 os::MEM_PROT_RWX);
2217 if (PrintMiscellaneous && Verbose) {
2218 char buf[256];
2219 jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2220 "at " INTPTR_FORMAT
2221 ", unguarding " INTPTR_FORMAT ": %s", addr,
2222 page_start, (res ? "success" : strerror(errno)));
2223 tty->print_raw_cr(buf);
2224 }
2226 // Set last_addr so if we fault again at the same address, we don't
2227 // end up in an endless loop.
2228 //
2229 // There are two potential complications here. Two threads trapping
2230 // at the same address at the same time could cause one of the
2231 // threads to think it already unguarded, and abort the VM. Likely
2232 // very rare.
2233 //
2234 // The other race involves two threads alternately trapping at
2235 // different addresses and failing to unguard the page, resulting in
2236 // an endless loop. This condition is probably even more unlikely
2237 // than the first.
2238 //
2239 // Although both cases could be avoided by using locks or thread
2240 // local last_addr, these solutions are unnecessary complication:
2241 // this handler is a best-effort safety net, not a complete solution.
2242 // It is disabled by default and should only be used as a workaround
2243 // in case we missed any no-execute-unsafe VM code.
2245 last_addr = addr;
2247 return EXCEPTION_CONTINUE_EXECUTION;
2248 }
2249 }
2251 // Last unguard failed or not unguarding
2252 tty->print_raw_cr("Execution protection violation");
2253 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2254 exceptionInfo->ContextRecord);
2255 return EXCEPTION_CONTINUE_SEARCH;
2256 }
2257 }
2258 #endif // _WIN64
2260 // Check to see if we caught the safepoint code in the
2261 // process of write protecting the memory serialization page.
2262 // It write enables the page immediately after protecting it
2263 // so just return.
2264 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2265 JavaThread* thread = (JavaThread*) t;
2266 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2267 address addr = (address) exceptionRecord->ExceptionInformation[1];
2268 if ( os::is_memory_serialize_page(thread, addr) ) {
2269 // Block current thread until the memory serialize page permission restored.
2270 os::block_on_serialize_page_trap();
2271 return EXCEPTION_CONTINUE_EXECUTION;
2272 }
2273 }
2275 if (t != NULL && t->is_Java_thread()) {
2276 JavaThread* thread = (JavaThread*) t;
2277 bool in_java = thread->thread_state() == _thread_in_Java;
2279 // Handle potential stack overflows up front.
2280 if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2281 if (os::uses_stack_guard_pages()) {
2282 #ifdef _M_IA64
2283 //
2284 // If it's a legal stack address continue, Windows will map it in.
2285 //
2286 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2287 address addr = (address) exceptionRecord->ExceptionInformation[1];
2288 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2289 return EXCEPTION_CONTINUE_EXECUTION;
2291 // The register save area is the same size as the memory stack
2292 // and starts at the page just above the start of the memory stack.
2293 // If we get a fault in this area, we've run out of register
2294 // stack. If we are in java, try throwing a stack overflow exception.
2295 if (addr > thread->stack_base() &&
2296 addr <= (thread->stack_base()+thread->stack_size()) ) {
2297 char buf[256];
2298 jio_snprintf(buf, sizeof(buf),
2299 "Register stack overflow, addr:%p, stack_base:%p\n",
2300 addr, thread->stack_base() );
2301 tty->print_raw_cr(buf);
2302 // If not in java code, return and hope for the best.
2303 return in_java ? Handle_Exception(exceptionInfo,
2304 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2305 : EXCEPTION_CONTINUE_EXECUTION;
2306 }
2307 #endif
2308 if (thread->stack_yellow_zone_enabled()) {
2309 // Yellow zone violation. The o/s has unprotected the first yellow
2310 // zone page for us. Note: must call disable_stack_yellow_zone to
2311 // update the enabled status, even if the zone contains only one page.
2312 thread->disable_stack_yellow_zone();
2313 // If not in java code, return and hope for the best.
2314 return in_java ? Handle_Exception(exceptionInfo,
2315 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2316 : EXCEPTION_CONTINUE_EXECUTION;
2317 } else {
2318 // Fatal red zone violation.
2319 thread->disable_stack_red_zone();
2320 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2321 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2322 exceptionInfo->ContextRecord);
2323 return EXCEPTION_CONTINUE_SEARCH;
2324 }
2325 } else if (in_java) {
2326 // JVM-managed guard pages cannot be used on win95/98. The o/s provides
2327 // a one-time-only guard page, which it has released to us. The next
2328 // stack overflow on this thread will result in an ACCESS_VIOLATION.
2329 return Handle_Exception(exceptionInfo,
2330 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2331 } else {
2332 // Can only return and hope for the best. Further stack growth will
2333 // result in an ACCESS_VIOLATION.
2334 return EXCEPTION_CONTINUE_EXECUTION;
2335 }
2336 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2337 // Either stack overflow or null pointer exception.
2338 if (in_java) {
2339 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2340 address addr = (address) exceptionRecord->ExceptionInformation[1];
2341 address stack_end = thread->stack_base() - thread->stack_size();
2342 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2343 // Stack overflow.
2344 assert(!os::uses_stack_guard_pages(),
2345 "should be caught by red zone code above.");
2346 return Handle_Exception(exceptionInfo,
2347 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2348 }
2349 //
2350 // Check for safepoint polling and implicit null
2351 // We only expect null pointers in the stubs (vtable)
2352 // the rest are checked explicitly now.
2353 //
2354 CodeBlob* cb = CodeCache::find_blob(pc);
2355 if (cb != NULL) {
2356 if (os::is_poll_address(addr)) {
2357 address stub = SharedRuntime::get_poll_stub(pc);
2358 return Handle_Exception(exceptionInfo, stub);
2359 }
2360 }
2361 {
2362 #ifdef _WIN64
2363 //
2364 // If it's a legal stack address map the entire region in
2365 //
2366 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2367 address addr = (address) exceptionRecord->ExceptionInformation[1];
2368 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2369 addr = (address)((uintptr_t)addr &
2370 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2371 os::commit_memory((char *)addr, thread->stack_base() - addr,
2372 false );
2373 return EXCEPTION_CONTINUE_EXECUTION;
2374 }
2375 else
2376 #endif
2377 {
2378 // Null pointer exception.
2379 #ifdef _M_IA64
2380 // We catch register stack overflows in compiled code by doing
2381 // an explicit compare and executing a st8(G0, G0) if the
2382 // BSP enters into our guard area. We test for the overflow
2383 // condition and fall into the normal null pointer exception
2384 // code if BSP hasn't overflowed.
2385 if ( in_java ) {
2386 if(thread->register_stack_overflow()) {
2387 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2388 thread->register_stack_limit(),
2389 "GR7 doesn't contain register_stack_limit");
2390 // Disable the yellow zone which sets the state that
2391 // we've got a stack overflow problem.
2392 if (thread->stack_yellow_zone_enabled()) {
2393 thread->disable_stack_yellow_zone();
2394 }
2395 // Give us some room to process the exception
2396 thread->disable_register_stack_guard();
2397 // Update GR7 with the new limit so we can continue running
2398 // compiled code.
2399 exceptionInfo->ContextRecord->IntS3 =
2400 (ULONGLONG)thread->register_stack_limit();
2401 return Handle_Exception(exceptionInfo,
2402 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2403 } else {
2404 //
2405 // Check for implicit null
2406 // We only expect null pointers in the stubs (vtable)
2407 // the rest are checked explicitly now.
2408 //
2409 if (((uintptr_t)addr) < os::vm_page_size() ) {
2410 // an access to the first page of VM--assume it is a null pointer
2411 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2412 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2413 }
2414 }
2415 } // in_java
2417 // IA64 doesn't use implicit null checking yet. So we shouldn't
2418 // get here.
2419 tty->print_raw_cr("Access violation, possible null pointer exception");
2420 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2421 exceptionInfo->ContextRecord);
2422 return EXCEPTION_CONTINUE_SEARCH;
2423 #else /* !IA64 */
2425 // Windows 98 reports faulting addresses incorrectly
2426 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2427 !os::win32::is_nt()) {
2428 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2429 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2430 }
2431 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2432 exceptionInfo->ContextRecord);
2433 return EXCEPTION_CONTINUE_SEARCH;
2434 #endif
2435 }
2436 }
2437 }
2439 #ifdef _WIN64
2440 // Special care for fast JNI field accessors.
2441 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2442 // in and the heap gets shrunk before the field access.
2443 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2444 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2445 if (addr != (address)-1) {
2446 return Handle_Exception(exceptionInfo, addr);
2447 }
2448 }
2449 #endif
2451 #ifdef _WIN64
2452 // Windows will sometimes generate an access violation
2453 // when we call malloc. Since we use VectoredExceptions
2454 // on 64 bit platforms, we see this exception. We must
2455 // pass this exception on so Windows can recover.
2456 // We check to see if the pc of the fault is in NTDLL.DLL
2457 // if so, we pass control on to Windows for handling.
2458 if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2459 #endif
2461 // Stack overflow or null pointer exception in native code.
2462 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2463 exceptionInfo->ContextRecord);
2464 return EXCEPTION_CONTINUE_SEARCH;
2465 }
2467 if (in_java) {
2468 switch (exception_code) {
2469 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2470 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2472 case EXCEPTION_INT_OVERFLOW:
2473 return Handle_IDiv_Exception(exceptionInfo);
2475 } // switch
2476 }
2477 #ifndef _WIN64
2478 if (((thread->thread_state() == _thread_in_Java) ||
2479 (thread->thread_state() == _thread_in_native)) &&
2480 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2481 {
2482 LONG result=Handle_FLT_Exception(exceptionInfo);
2483 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2484 }
2485 #endif //_WIN64
2486 }
2488 if (exception_code != EXCEPTION_BREAKPOINT) {
2489 #ifndef _WIN64
2490 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2491 exceptionInfo->ContextRecord);
2492 #else
2493 // Itanium Windows uses a VectoredExceptionHandler
2494 // Which means that C++ programatic exception handlers (try/except)
2495 // will get here. Continue the search for the right except block if
2496 // the exception code is not a fatal code.
2497 switch ( exception_code ) {
2498 case EXCEPTION_ACCESS_VIOLATION:
2499 case EXCEPTION_STACK_OVERFLOW:
2500 case EXCEPTION_ILLEGAL_INSTRUCTION:
2501 case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2502 case EXCEPTION_INT_OVERFLOW:
2503 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2504 case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
2505 { report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2506 exceptionInfo->ContextRecord);
2507 }
2508 break;
2509 default:
2510 break;
2511 }
2512 #endif
2513 }
2514 return EXCEPTION_CONTINUE_SEARCH;
2515 }
2517 #ifndef _WIN64
2518 // Special care for fast JNI accessors.
2519 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2520 // the heap gets shrunk before the field access.
2521 // Need to install our own structured exception handler since native code may
2522 // install its own.
2523 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2524 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2525 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2526 address pc = (address) exceptionInfo->ContextRecord->Eip;
2527 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2528 if (addr != (address)-1) {
2529 return Handle_Exception(exceptionInfo, addr);
2530 }
2531 }
2532 return EXCEPTION_CONTINUE_SEARCH;
2533 }
2535 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2536 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2537 __try { \
2538 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2539 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2540 } \
2541 return 0; \
2542 }
2544 DEFINE_FAST_GETFIELD(jboolean, bool, Boolean)
2545 DEFINE_FAST_GETFIELD(jbyte, byte, Byte)
2546 DEFINE_FAST_GETFIELD(jchar, char, Char)
2547 DEFINE_FAST_GETFIELD(jshort, short, Short)
2548 DEFINE_FAST_GETFIELD(jint, int, Int)
2549 DEFINE_FAST_GETFIELD(jlong, long, Long)
2550 DEFINE_FAST_GETFIELD(jfloat, float, Float)
2551 DEFINE_FAST_GETFIELD(jdouble, double, Double)
2553 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2554 switch (type) {
2555 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2556 case T_BYTE: return (address)jni_fast_GetByteField_wrapper;
2557 case T_CHAR: return (address)jni_fast_GetCharField_wrapper;
2558 case T_SHORT: return (address)jni_fast_GetShortField_wrapper;
2559 case T_INT: return (address)jni_fast_GetIntField_wrapper;
2560 case T_LONG: return (address)jni_fast_GetLongField_wrapper;
2561 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper;
2562 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper;
2563 default: ShouldNotReachHere();
2564 }
2565 return (address)-1;
2566 }
2567 #endif
2569 // Virtual Memory
2571 int os::vm_page_size() { return os::win32::vm_page_size(); }
2572 int os::vm_allocation_granularity() {
2573 return os::win32::vm_allocation_granularity();
2574 }
2576 // Windows large page support is available on Windows 2003. In order to use
2577 // large page memory, the administrator must first assign additional privilege
2578 // to the user:
2579 // + select Control Panel -> Administrative Tools -> Local Security Policy
2580 // + select Local Policies -> User Rights Assignment
2581 // + double click "Lock pages in memory", add users and/or groups
2582 // + reboot
2583 // Note the above steps are needed for administrator as well, as administrators
2584 // by default do not have the privilege to lock pages in memory.
2585 //
2586 // Note about Windows 2003: although the API supports committing large page
2587 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2588 // scenario, I found through experiment it only uses large page if the entire
2589 // memory region is reserved and committed in a single VirtualAlloc() call.
2590 // This makes Windows large page support more or less like Solaris ISM, in
2591 // that the entire heap must be committed upfront. This probably will change
2592 // in the future, if so the code below needs to be revisited.
2594 #ifndef MEM_LARGE_PAGES
2595 #define MEM_LARGE_PAGES 0x20000000
2596 #endif
2598 // GetLargePageMinimum is only available on Windows 2003. The other functions
2599 // are available on NT but not on Windows 98/Me. We have to resolve them at
2600 // runtime.
2601 typedef SIZE_T (WINAPI *GetLargePageMinimum_func_type) (void);
2602 typedef BOOL (WINAPI *AdjustTokenPrivileges_func_type)
2603 (HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
2604 typedef BOOL (WINAPI *OpenProcessToken_func_type) (HANDLE, DWORD, PHANDLE);
2605 typedef BOOL (WINAPI *LookupPrivilegeValue_func_type) (LPCTSTR, LPCTSTR, PLUID);
2607 static GetLargePageMinimum_func_type _GetLargePageMinimum;
2608 static AdjustTokenPrivileges_func_type _AdjustTokenPrivileges;
2609 static OpenProcessToken_func_type _OpenProcessToken;
2610 static LookupPrivilegeValue_func_type _LookupPrivilegeValue;
2612 static HINSTANCE _kernel32;
2613 static HINSTANCE _advapi32;
2614 static HANDLE _hProcess;
2615 static HANDLE _hToken;
2617 static size_t _large_page_size = 0;
2619 static bool resolve_functions_for_large_page_init() {
2620 _kernel32 = LoadLibrary("kernel32.dll");
2621 if (_kernel32 == NULL) return false;
2623 _GetLargePageMinimum = CAST_TO_FN_PTR(GetLargePageMinimum_func_type,
2624 GetProcAddress(_kernel32, "GetLargePageMinimum"));
2625 if (_GetLargePageMinimum == NULL) return false;
2627 _advapi32 = LoadLibrary("advapi32.dll");
2628 if (_advapi32 == NULL) return false;
2630 _AdjustTokenPrivileges = CAST_TO_FN_PTR(AdjustTokenPrivileges_func_type,
2631 GetProcAddress(_advapi32, "AdjustTokenPrivileges"));
2632 _OpenProcessToken = CAST_TO_FN_PTR(OpenProcessToken_func_type,
2633 GetProcAddress(_advapi32, "OpenProcessToken"));
2634 _LookupPrivilegeValue = CAST_TO_FN_PTR(LookupPrivilegeValue_func_type,
2635 GetProcAddress(_advapi32, "LookupPrivilegeValueA"));
2636 return _AdjustTokenPrivileges != NULL &&
2637 _OpenProcessToken != NULL &&
2638 _LookupPrivilegeValue != NULL;
2639 }
2641 static bool request_lock_memory_privilege() {
2642 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2643 os::current_process_id());
2645 LUID luid;
2646 if (_hProcess != NULL &&
2647 _OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2648 _LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2650 TOKEN_PRIVILEGES tp;
2651 tp.PrivilegeCount = 1;
2652 tp.Privileges[0].Luid = luid;
2653 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2655 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2656 // privilege. Check GetLastError() too. See MSDN document.
2657 if (_AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2658 (GetLastError() == ERROR_SUCCESS)) {
2659 return true;
2660 }
2661 }
2663 return false;
2664 }
2666 static void cleanup_after_large_page_init() {
2667 _GetLargePageMinimum = NULL;
2668 _AdjustTokenPrivileges = NULL;
2669 _OpenProcessToken = NULL;
2670 _LookupPrivilegeValue = NULL;
2671 if (_kernel32) FreeLibrary(_kernel32);
2672 _kernel32 = NULL;
2673 if (_advapi32) FreeLibrary(_advapi32);
2674 _advapi32 = NULL;
2675 if (_hProcess) CloseHandle(_hProcess);
2676 _hProcess = NULL;
2677 if (_hToken) CloseHandle(_hToken);
2678 _hToken = NULL;
2679 }
2681 bool os::large_page_init() {
2682 if (!UseLargePages) return false;
2684 // print a warning if any large page related flag is specified on command line
2685 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2686 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2687 bool success = false;
2689 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2690 if (resolve_functions_for_large_page_init()) {
2691 if (request_lock_memory_privilege()) {
2692 size_t s = _GetLargePageMinimum();
2693 if (s) {
2694 #if defined(IA32) || defined(AMD64)
2695 if (s > 4*M || LargePageSizeInBytes > 4*M) {
2696 WARN("JVM cannot use large pages bigger than 4mb.");
2697 } else {
2698 #endif
2699 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2700 _large_page_size = LargePageSizeInBytes;
2701 } else {
2702 _large_page_size = s;
2703 }
2704 success = true;
2705 #if defined(IA32) || defined(AMD64)
2706 }
2707 #endif
2708 } else {
2709 WARN("Large page is not supported by the processor.");
2710 }
2711 } else {
2712 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2713 }
2714 } else {
2715 WARN("Large page is not supported by the operating system.");
2716 }
2717 #undef WARN
2719 const size_t default_page_size = (size_t) vm_page_size();
2720 if (success && _large_page_size > default_page_size) {
2721 _page_sizes[0] = _large_page_size;
2722 _page_sizes[1] = default_page_size;
2723 _page_sizes[2] = 0;
2724 }
2726 cleanup_after_large_page_init();
2727 return success;
2728 }
2730 // On win32, one cannot release just a part of reserved memory, it's an
2731 // all or nothing deal. When we split a reservation, we must break the
2732 // reservation into two reservations.
2733 void os::split_reserved_memory(char *base, size_t size, size_t split,
2734 bool realloc) {
2735 if (size > 0) {
2736 release_memory(base, size);
2737 if (realloc) {
2738 reserve_memory(split, base);
2739 }
2740 if (size != split) {
2741 reserve_memory(size - split, base + split);
2742 }
2743 }
2744 }
2746 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2747 assert((size_t)addr % os::vm_allocation_granularity() == 0,
2748 "reserve alignment");
2749 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2750 char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2751 assert(res == NULL || addr == NULL || addr == res,
2752 "Unexpected address from reserve.");
2753 return res;
2754 }
2756 // Reserve memory at an arbitrary address, only if that area is
2757 // available (and not reserved for something else).
2758 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2759 // Windows os::reserve_memory() fails of the requested address range is
2760 // not avilable.
2761 return reserve_memory(bytes, requested_addr);
2762 }
2764 size_t os::large_page_size() {
2765 return _large_page_size;
2766 }
2768 bool os::can_commit_large_page_memory() {
2769 // Windows only uses large page memory when the entire region is reserved
2770 // and committed in a single VirtualAlloc() call. This may change in the
2771 // future, but with Windows 2003 it's not possible to commit on demand.
2772 return false;
2773 }
2775 bool os::can_execute_large_page_memory() {
2776 return true;
2777 }
2779 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2781 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
2783 if (UseLargePagesIndividualAllocation) {
2784 if (TracePageSizes && Verbose) {
2785 tty->print_cr("Reserving large pages individually.");
2786 }
2787 char * p_buf;
2788 // first reserve enough address space in advance since we want to be
2789 // able to break a single contiguous virtual address range into multiple
2790 // large page commits but WS2003 does not allow reserving large page space
2791 // so we just use 4K pages for reserve, this gives us a legal contiguous
2792 // address space. then we will deallocate that reservation, and re alloc
2793 // using large pages
2794 const size_t size_of_reserve = bytes + _large_page_size;
2795 if (bytes > size_of_reserve) {
2796 // Overflowed.
2797 warning("Individually allocated large pages failed, "
2798 "use -XX:-UseLargePagesIndividualAllocation to turn off");
2799 return NULL;
2800 }
2801 p_buf = (char *) VirtualAlloc(addr,
2802 size_of_reserve, // size of Reserve
2803 MEM_RESERVE,
2804 PAGE_READWRITE);
2805 // If reservation failed, return NULL
2806 if (p_buf == NULL) return NULL;
2808 release_memory(p_buf, bytes + _large_page_size);
2809 // round up to page boundary. If the size_of_reserve did not
2810 // overflow and the reservation did not fail, this align up
2811 // should not overflow.
2812 p_buf = (char *) align_size_up((size_t)p_buf, _large_page_size);
2814 // now go through and allocate one page at a time until all bytes are
2815 // allocated
2816 size_t bytes_remaining = align_size_up(bytes, _large_page_size);
2817 // An overflow of align_size_up() would have been caught above
2818 // in the calculation of size_of_reserve.
2819 char * next_alloc_addr = p_buf;
2821 #ifdef ASSERT
2822 // Variable for the failure injection
2823 long ran_num = os::random();
2824 size_t fail_after = ran_num % bytes;
2825 #endif
2827 while (bytes_remaining) {
2828 size_t bytes_to_rq = MIN2(bytes_remaining, _large_page_size);
2829 // Note allocate and commit
2830 char * p_new;
2832 #ifdef ASSERT
2833 bool inject_error = LargePagesIndividualAllocationInjectError &&
2834 (bytes_remaining <= fail_after);
2835 #else
2836 const bool inject_error = false;
2837 #endif
2839 if (inject_error) {
2840 p_new = NULL;
2841 } else {
2842 p_new = (char *) VirtualAlloc(next_alloc_addr,
2843 bytes_to_rq,
2844 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES,
2845 prot);
2846 }
2848 if (p_new == NULL) {
2849 // Free any allocated pages
2850 if (next_alloc_addr > p_buf) {
2851 // Some memory was committed so release it.
2852 size_t bytes_to_release = bytes - bytes_remaining;
2853 release_memory(p_buf, bytes_to_release);
2854 }
2855 #ifdef ASSERT
2856 if (UseLargePagesIndividualAllocation &&
2857 LargePagesIndividualAllocationInjectError) {
2858 if (TracePageSizes && Verbose) {
2859 tty->print_cr("Reserving large pages individually failed.");
2860 }
2861 }
2862 #endif
2863 return NULL;
2864 }
2865 bytes_remaining -= bytes_to_rq;
2866 next_alloc_addr += bytes_to_rq;
2867 }
2869 return p_buf;
2871 } else {
2872 // normal policy just allocate it all at once
2873 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2874 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
2875 return res;
2876 }
2877 }
2879 bool os::release_memory_special(char* base, size_t bytes) {
2880 return release_memory(base, bytes);
2881 }
2883 void os::print_statistics() {
2884 }
2886 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
2887 if (bytes == 0) {
2888 // Don't bother the OS with noops.
2889 return true;
2890 }
2891 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
2892 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
2893 // Don't attempt to print anything if the OS call fails. We're
2894 // probably low on resources, so the print itself may cause crashes.
2895 bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0;
2896 if (result != NULL && exec) {
2897 DWORD oldprot;
2898 // Windows doc says to use VirtualProtect to get execute permissions
2899 return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0;
2900 } else {
2901 return result;
2902 }
2903 }
2905 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
2906 bool exec) {
2907 return commit_memory(addr, size, exec);
2908 }
2910 bool os::uncommit_memory(char* addr, size_t bytes) {
2911 if (bytes == 0) {
2912 // Don't bother the OS with noops.
2913 return true;
2914 }
2915 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
2916 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
2917 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0;
2918 }
2920 bool os::release_memory(char* addr, size_t bytes) {
2921 return VirtualFree(addr, 0, MEM_RELEASE) != 0;
2922 }
2924 bool os::create_stack_guard_pages(char* addr, size_t size) {
2925 return os::commit_memory(addr, size);
2926 }
2928 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2929 return os::uncommit_memory(addr, size);
2930 }
2932 // Set protections specified
2933 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
2934 bool is_committed) {
2935 unsigned int p = 0;
2936 switch (prot) {
2937 case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
2938 case MEM_PROT_READ: p = PAGE_READONLY; break;
2939 case MEM_PROT_RW: p = PAGE_READWRITE; break;
2940 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break;
2941 default:
2942 ShouldNotReachHere();
2943 }
2945 DWORD old_status;
2947 // Strange enough, but on Win32 one can change protection only for committed
2948 // memory, not a big deal anyway, as bytes less or equal than 64K
2949 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
2950 fatal("cannot commit protection page");
2951 }
2952 // One cannot use os::guard_memory() here, as on Win32 guard page
2953 // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
2954 //
2955 // Pages in the region become guard pages. Any attempt to access a guard page
2956 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
2957 // the guard page status. Guard pages thus act as a one-time access alarm.
2958 return VirtualProtect(addr, bytes, p, &old_status) != 0;
2959 }
2961 bool os::guard_memory(char* addr, size_t bytes) {
2962 DWORD old_status;
2963 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
2964 }
2966 bool os::unguard_memory(char* addr, size_t bytes) {
2967 DWORD old_status;
2968 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
2969 }
2971 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
2972 void os::free_memory(char *addr, size_t bytes) { }
2973 void os::numa_make_global(char *addr, size_t bytes) { }
2974 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { }
2975 bool os::numa_topology_changed() { return false; }
2976 size_t os::numa_get_groups_num() { return 1; }
2977 int os::numa_get_group_id() { return 0; }
2978 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2979 if (size > 0) {
2980 ids[0] = 0;
2981 return 1;
2982 }
2983 return 0;
2984 }
2986 bool os::get_page_info(char *start, page_info* info) {
2987 return false;
2988 }
2990 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2991 return end;
2992 }
2994 char* os::non_memory_address_word() {
2995 // Must never look like an address returned by reserve_memory,
2996 // even in its subfields (as defined by the CPU immediate fields,
2997 // if the CPU splits constants across multiple instructions).
2998 return (char*)-1;
2999 }
3001 #define MAX_ERROR_COUNT 100
3002 #define SYS_THREAD_ERROR 0xffffffffUL
3004 void os::pd_start_thread(Thread* thread) {
3005 DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3006 // Returns previous suspend state:
3007 // 0: Thread was not suspended
3008 // 1: Thread is running now
3009 // >1: Thread is still suspended.
3010 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3011 }
3013 class HighResolutionInterval {
3014 // The default timer resolution seems to be 10 milliseconds.
3015 // (Where is this written down?)
3016 // If someone wants to sleep for only a fraction of the default,
3017 // then we set the timer resolution down to 1 millisecond for
3018 // the duration of their interval.
3019 // We carefully set the resolution back, since otherwise we
3020 // seem to incur an overhead (3%?) that we don't need.
3021 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3022 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3023 // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3024 // timeBeginPeriod() if the relative error exceeded some threshold.
3025 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3026 // to decreased efficiency related to increased timer "tick" rates. We want to minimize
3027 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3028 // resolution timers running.
3029 private:
3030 jlong resolution;
3031 public:
3032 HighResolutionInterval(jlong ms) {
3033 resolution = ms % 10L;
3034 if (resolution != 0) {
3035 MMRESULT result = timeBeginPeriod(1L);
3036 }
3037 }
3038 ~HighResolutionInterval() {
3039 if (resolution != 0) {
3040 MMRESULT result = timeEndPeriod(1L);
3041 }
3042 resolution = 0L;
3043 }
3044 };
3046 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3047 jlong limit = (jlong) MAXDWORD;
3049 while(ms > limit) {
3050 int res;
3051 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3052 return res;
3053 ms -= limit;
3054 }
3056 assert(thread == Thread::current(), "thread consistency check");
3057 OSThread* osthread = thread->osthread();
3058 OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3059 int result;
3060 if (interruptable) {
3061 assert(thread->is_Java_thread(), "must be java thread");
3062 JavaThread *jt = (JavaThread *) thread;
3063 ThreadBlockInVM tbivm(jt);
3065 jt->set_suspend_equivalent();
3066 // cleared by handle_special_suspend_equivalent_condition() or
3067 // java_suspend_self() via check_and_wait_while_suspended()
3069 HANDLE events[1];
3070 events[0] = osthread->interrupt_event();
3071 HighResolutionInterval *phri=NULL;
3072 if(!ForceTimeHighResolution)
3073 phri = new HighResolutionInterval( ms );
3074 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3075 result = OS_TIMEOUT;
3076 } else {
3077 ResetEvent(osthread->interrupt_event());
3078 osthread->set_interrupted(false);
3079 result = OS_INTRPT;
3080 }
3081 delete phri; //if it is NULL, harmless
3083 // were we externally suspended while we were waiting?
3084 jt->check_and_wait_while_suspended();
3085 } else {
3086 assert(!thread->is_Java_thread(), "must not be java thread");
3087 Sleep((long) ms);
3088 result = OS_TIMEOUT;
3089 }
3090 return result;
3091 }
3093 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3094 void os::infinite_sleep() {
3095 while (true) { // sleep forever ...
3096 Sleep(100000); // ... 100 seconds at a time
3097 }
3098 }
3100 typedef BOOL (WINAPI * STTSignature)(void) ;
3102 os::YieldResult os::NakedYield() {
3103 // Use either SwitchToThread() or Sleep(0)
3104 // Consider passing back the return value from SwitchToThread().
3105 // We use GetProcAddress() as ancient Win9X versions of windows doen't support SwitchToThread.
3106 // In that case we revert to Sleep(0).
3107 static volatile STTSignature stt = (STTSignature) 1 ;
3109 if (stt == ((STTSignature) 1)) {
3110 stt = (STTSignature) ::GetProcAddress (LoadLibrary ("Kernel32.dll"), "SwitchToThread") ;
3111 // It's OK if threads race during initialization as the operation above is idempotent.
3112 }
3113 if (stt != NULL) {
3114 return (*stt)() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3115 } else {
3116 Sleep (0) ;
3117 }
3118 return os::YIELD_UNKNOWN ;
3119 }
3121 void os::yield() { os::NakedYield(); }
3123 void os::yield_all(int attempts) {
3124 // Yields to all threads, including threads with lower priorities
3125 Sleep(1);
3126 }
3128 // Win32 only gives you access to seven real priorities at a time,
3129 // so we compress Java's ten down to seven. It would be better
3130 // if we dynamically adjusted relative priorities.
3132 int os::java_to_os_priority[MaxPriority + 1] = {
3133 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3134 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3135 THREAD_PRIORITY_LOWEST, // 2
3136 THREAD_PRIORITY_BELOW_NORMAL, // 3
3137 THREAD_PRIORITY_BELOW_NORMAL, // 4
3138 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3139 THREAD_PRIORITY_NORMAL, // 6
3140 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3141 THREAD_PRIORITY_ABOVE_NORMAL, // 8
3142 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3143 THREAD_PRIORITY_HIGHEST // 10 MaxPriority
3144 };
3146 int prio_policy1[MaxPriority + 1] = {
3147 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3148 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3149 THREAD_PRIORITY_LOWEST, // 2
3150 THREAD_PRIORITY_BELOW_NORMAL, // 3
3151 THREAD_PRIORITY_BELOW_NORMAL, // 4
3152 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3153 THREAD_PRIORITY_ABOVE_NORMAL, // 6
3154 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3155 THREAD_PRIORITY_HIGHEST, // 8
3156 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3157 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority
3158 };
3160 static int prio_init() {
3161 // If ThreadPriorityPolicy is 1, switch tables
3162 if (ThreadPriorityPolicy == 1) {
3163 int i;
3164 for (i = 0; i < MaxPriority + 1; i++) {
3165 os::java_to_os_priority[i] = prio_policy1[i];
3166 }
3167 }
3168 return 0;
3169 }
3171 OSReturn os::set_native_priority(Thread* thread, int priority) {
3172 if (!UseThreadPriorities) return OS_OK;
3173 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3174 return ret ? OS_OK : OS_ERR;
3175 }
3177 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3178 if ( !UseThreadPriorities ) {
3179 *priority_ptr = java_to_os_priority[NormPriority];
3180 return OS_OK;
3181 }
3182 int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3183 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3184 assert(false, "GetThreadPriority failed");
3185 return OS_ERR;
3186 }
3187 *priority_ptr = os_prio;
3188 return OS_OK;
3189 }
3192 // Hint to the underlying OS that a task switch would not be good.
3193 // Void return because it's a hint and can fail.
3194 void os::hint_no_preempt() {}
3196 void os::interrupt(Thread* thread) {
3197 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3198 "possibility of dangling Thread pointer");
3200 OSThread* osthread = thread->osthread();
3201 osthread->set_interrupted(true);
3202 // More than one thread can get here with the same value of osthread,
3203 // resulting in multiple notifications. We do, however, want the store
3204 // to interrupted() to be visible to other threads before we post
3205 // the interrupt event.
3206 OrderAccess::release();
3207 SetEvent(osthread->interrupt_event());
3208 // For JSR166: unpark after setting status
3209 if (thread->is_Java_thread())
3210 ((JavaThread*)thread)->parker()->unpark();
3212 ParkEvent * ev = thread->_ParkEvent ;
3213 if (ev != NULL) ev->unpark() ;
3215 }
3218 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3219 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3220 "possibility of dangling Thread pointer");
3222 OSThread* osthread = thread->osthread();
3223 bool interrupted;
3224 interrupted = osthread->interrupted();
3225 if (clear_interrupted == true) {
3226 osthread->set_interrupted(false);
3227 ResetEvent(osthread->interrupt_event());
3228 } // Otherwise leave the interrupted state alone
3230 return interrupted;
3231 }
3233 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3234 ExtendedPC os::get_thread_pc(Thread* thread) {
3235 CONTEXT context;
3236 context.ContextFlags = CONTEXT_CONTROL;
3237 HANDLE handle = thread->osthread()->thread_handle();
3238 #ifdef _M_IA64
3239 assert(0, "Fix get_thread_pc");
3240 return ExtendedPC(NULL);
3241 #else
3242 if (GetThreadContext(handle, &context)) {
3243 #ifdef _M_AMD64
3244 return ExtendedPC((address) context.Rip);
3245 #else
3246 return ExtendedPC((address) context.Eip);
3247 #endif
3248 } else {
3249 return ExtendedPC(NULL);
3250 }
3251 #endif
3252 }
3254 // GetCurrentThreadId() returns DWORD
3255 intx os::current_thread_id() { return GetCurrentThreadId(); }
3257 static int _initial_pid = 0;
3259 int os::current_process_id()
3260 {
3261 return (_initial_pid ? _initial_pid : _getpid());
3262 }
3264 int os::win32::_vm_page_size = 0;
3265 int os::win32::_vm_allocation_granularity = 0;
3266 int os::win32::_processor_type = 0;
3267 // Processor level is not available on non-NT systems, use vm_version instead
3268 int os::win32::_processor_level = 0;
3269 julong os::win32::_physical_memory = 0;
3270 size_t os::win32::_default_stack_size = 0;
3272 intx os::win32::_os_thread_limit = 0;
3273 volatile intx os::win32::_os_thread_count = 0;
3275 bool os::win32::_is_nt = false;
3276 bool os::win32::_is_windows_2003 = false;
3279 void os::win32::initialize_system_info() {
3280 SYSTEM_INFO si;
3281 GetSystemInfo(&si);
3282 _vm_page_size = si.dwPageSize;
3283 _vm_allocation_granularity = si.dwAllocationGranularity;
3284 _processor_type = si.dwProcessorType;
3285 _processor_level = si.wProcessorLevel;
3286 set_processor_count(si.dwNumberOfProcessors);
3288 MEMORYSTATUSEX ms;
3289 ms.dwLength = sizeof(ms);
3291 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3292 // dwMemoryLoad (% of memory in use)
3293 GlobalMemoryStatusEx(&ms);
3294 _physical_memory = ms.ullTotalPhys;
3296 OSVERSIONINFO oi;
3297 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
3298 GetVersionEx(&oi);
3299 switch(oi.dwPlatformId) {
3300 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3301 case VER_PLATFORM_WIN32_NT:
3302 _is_nt = true;
3303 {
3304 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3305 if (os_vers == 5002) {
3306 _is_windows_2003 = true;
3307 }
3308 }
3309 break;
3310 default: fatal("Unknown platform");
3311 }
3313 _default_stack_size = os::current_stack_size();
3314 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3315 assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3316 "stack size not a multiple of page size");
3318 initialize_performance_counter();
3320 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3321 // known to deadlock the system, if the VM issues to thread operations with
3322 // a too high frequency, e.g., such as changing the priorities.
3323 // The 6000 seems to work well - no deadlocks has been notices on the test
3324 // programs that we have seen experience this problem.
3325 if (!os::win32::is_nt()) {
3326 StarvationMonitorInterval = 6000;
3327 }
3328 }
3331 void os::win32::setmode_streams() {
3332 _setmode(_fileno(stdin), _O_BINARY);
3333 _setmode(_fileno(stdout), _O_BINARY);
3334 _setmode(_fileno(stderr), _O_BINARY);
3335 }
3338 int os::message_box(const char* title, const char* message) {
3339 int result = MessageBox(NULL, message, title,
3340 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3341 return result == IDYES;
3342 }
3344 int os::allocate_thread_local_storage() {
3345 return TlsAlloc();
3346 }
3349 void os::free_thread_local_storage(int index) {
3350 TlsFree(index);
3351 }
3354 void os::thread_local_storage_at_put(int index, void* value) {
3355 TlsSetValue(index, value);
3356 assert(thread_local_storage_at(index) == value, "Just checking");
3357 }
3360 void* os::thread_local_storage_at(int index) {
3361 return TlsGetValue(index);
3362 }
3365 #ifndef PRODUCT
3366 #ifndef _WIN64
3367 // Helpers to check whether NX protection is enabled
3368 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3369 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3370 pex->ExceptionRecord->NumberParameters > 0 &&
3371 pex->ExceptionRecord->ExceptionInformation[0] ==
3372 EXCEPTION_INFO_EXEC_VIOLATION) {
3373 return EXCEPTION_EXECUTE_HANDLER;
3374 }
3375 return EXCEPTION_CONTINUE_SEARCH;
3376 }
3378 void nx_check_protection() {
3379 // If NX is enabled we'll get an exception calling into code on the stack
3380 char code[] = { (char)0xC3 }; // ret
3381 void *code_ptr = (void *)code;
3382 __try {
3383 __asm call code_ptr
3384 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3385 tty->print_raw_cr("NX protection detected.");
3386 }
3387 }
3388 #endif // _WIN64
3389 #endif // PRODUCT
3391 // this is called _before_ the global arguments have been parsed
3392 void os::init(void) {
3393 _initial_pid = _getpid();
3395 init_random(1234567);
3397 win32::initialize_system_info();
3398 win32::setmode_streams();
3399 init_page_sizes((size_t) win32::vm_page_size());
3401 // For better scalability on MP systems (must be called after initialize_system_info)
3402 #ifndef PRODUCT
3403 if (is_MP()) {
3404 NoYieldsInMicrolock = true;
3405 }
3406 #endif
3407 // This may be overridden later when argument processing is done.
3408 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3409 os::win32::is_windows_2003());
3411 // Initialize main_process and main_thread
3412 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle
3413 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3414 &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3415 fatal("DuplicateHandle failed\n");
3416 }
3417 main_thread_id = (int) GetCurrentThreadId();
3418 }
3420 // To install functions for atexit processing
3421 extern "C" {
3422 static void perfMemory_exit_helper() {
3423 perfMemory_exit();
3424 }
3425 }
3427 // this is called _after_ the global arguments have been parsed
3428 jint os::init_2(void) {
3429 // Allocate a single page and mark it as readable for safepoint polling
3430 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3431 guarantee( polling_page != NULL, "Reserve Failed for polling page");
3433 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3434 guarantee( return_page != NULL, "Commit Failed for polling page");
3436 os::set_polling_page( polling_page );
3438 #ifndef PRODUCT
3439 if( Verbose && PrintMiscellaneous )
3440 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3441 #endif
3443 if (!UseMembar) {
3444 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3445 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3447 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3448 guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3450 os::set_memory_serialize_page( mem_serialize_page );
3452 #ifndef PRODUCT
3453 if(Verbose && PrintMiscellaneous)
3454 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3455 #endif
3456 }
3458 FLAG_SET_DEFAULT(UseLargePages, os::large_page_init());
3460 // Setup Windows Exceptions
3462 // On Itanium systems, Structured Exception Handling does not
3463 // work since stack frames must be walkable by the OS. Since
3464 // much of our code is dynamically generated, and we do not have
3465 // proper unwind .xdata sections, the system simply exits
3466 // rather than delivering the exception. To work around
3467 // this we use VectorExceptions instead.
3468 #ifdef _WIN64
3469 if (UseVectoredExceptions) {
3470 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3471 }
3472 #endif
3474 // for debugging float code generation bugs
3475 if (ForceFloatExceptions) {
3476 #ifndef _WIN64
3477 static long fp_control_word = 0;
3478 __asm { fstcw fp_control_word }
3479 // see Intel PPro Manual, Vol. 2, p 7-16
3480 const long precision = 0x20;
3481 const long underflow = 0x10;
3482 const long overflow = 0x08;
3483 const long zero_div = 0x04;
3484 const long denorm = 0x02;
3485 const long invalid = 0x01;
3486 fp_control_word |= invalid;
3487 __asm { fldcw fp_control_word }
3488 #endif
3489 }
3491 // If stack_commit_size is 0, windows will reserve the default size,
3492 // but only commit a small portion of it.
3493 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3494 size_t default_reserve_size = os::win32::default_stack_size();
3495 size_t actual_reserve_size = stack_commit_size;
3496 if (stack_commit_size < default_reserve_size) {
3497 // If stack_commit_size == 0, we want this too
3498 actual_reserve_size = default_reserve_size;
3499 }
3501 // Check minimum allowable stack size for thread creation and to initialize
3502 // the java system classes, including StackOverflowError - depends on page
3503 // size. Add a page for compiler2 recursion in main thread.
3504 // Add in 2*BytesPerWord times page size to account for VM stack during
3505 // class initialization depending on 32 or 64 bit VM.
3506 size_t min_stack_allowed =
3507 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3508 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3509 if (actual_reserve_size < min_stack_allowed) {
3510 tty->print_cr("\nThe stack size specified is too small, "
3511 "Specify at least %dk",
3512 min_stack_allowed / K);
3513 return JNI_ERR;
3514 }
3516 JavaThread::set_stack_size_at_create(stack_commit_size);
3518 // Calculate theoretical max. size of Threads to guard gainst artifical
3519 // out-of-memory situations, where all available address-space has been
3520 // reserved by thread stacks.
3521 assert(actual_reserve_size != 0, "Must have a stack");
3523 // Calculate the thread limit when we should start doing Virtual Memory
3524 // banging. Currently when the threads will have used all but 200Mb of space.
3525 //
3526 // TODO: consider performing a similar calculation for commit size instead
3527 // as reserve size, since on a 64-bit platform we'll run into that more
3528 // often than running out of virtual memory space. We can use the
3529 // lower value of the two calculations as the os_thread_limit.
3530 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3531 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3533 // at exit methods are called in the reverse order of their registration.
3534 // there is no limit to the number of functions registered. atexit does
3535 // not set errno.
3537 if (PerfAllowAtExitRegistration) {
3538 // only register atexit functions if PerfAllowAtExitRegistration is set.
3539 // atexit functions can be delayed until process exit time, which
3540 // can be problematic for embedded VM situations. Embedded VMs should
3541 // call DestroyJavaVM() to assure that VM resources are released.
3543 // note: perfMemory_exit_helper atexit function may be removed in
3544 // the future if the appropriate cleanup code can be added to the
3545 // VM_Exit VMOperation's doit method.
3546 if (atexit(perfMemory_exit_helper) != 0) {
3547 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3548 }
3549 }
3551 // initialize PSAPI or ToolHelp for fatal error handler
3552 if (win32::is_nt()) _init_psapi();
3553 else _init_toolhelp();
3555 #ifndef _WIN64
3556 // Print something if NX is enabled (win32 on AMD64)
3557 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3558 #endif
3560 // initialize thread priority policy
3561 prio_init();
3563 if (UseNUMA && !ForceNUMA) {
3564 UseNUMA = false; // Currently unsupported.
3565 }
3567 return JNI_OK;
3568 }
3570 void os::init_3(void) {
3571 return;
3572 }
3574 // Mark the polling page as unreadable
3575 void os::make_polling_page_unreadable(void) {
3576 DWORD old_status;
3577 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3578 fatal("Could not disable polling page");
3579 };
3581 // Mark the polling page as readable
3582 void os::make_polling_page_readable(void) {
3583 DWORD old_status;
3584 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3585 fatal("Could not enable polling page");
3586 };
3589 int os::stat(const char *path, struct stat *sbuf) {
3590 char pathbuf[MAX_PATH];
3591 if (strlen(path) > MAX_PATH - 1) {
3592 errno = ENAMETOOLONG;
3593 return -1;
3594 }
3595 os::native_path(strcpy(pathbuf, path));
3596 int ret = ::stat(pathbuf, sbuf);
3597 if (sbuf != NULL && UseUTCFileTimestamp) {
3598 // Fix for 6539723. st_mtime returned from stat() is dependent on
3599 // the system timezone and so can return different values for the
3600 // same file if/when daylight savings time changes. This adjustment
3601 // makes sure the same timestamp is returned regardless of the TZ.
3602 //
3603 // See:
3604 // http://msdn.microsoft.com/library/
3605 // default.asp?url=/library/en-us/sysinfo/base/
3606 // time_zone_information_str.asp
3607 // and
3608 // http://msdn.microsoft.com/library/default.asp?url=
3609 // /library/en-us/sysinfo/base/settimezoneinformation.asp
3610 //
3611 // NOTE: there is a insidious bug here: If the timezone is changed
3612 // after the call to stat() but before 'GetTimeZoneInformation()', then
3613 // the adjustment we do here will be wrong and we'll return the wrong
3614 // value (which will likely end up creating an invalid class data
3615 // archive). Absent a better API for this, or some time zone locking
3616 // mechanism, we'll have to live with this risk.
3617 TIME_ZONE_INFORMATION tz;
3618 DWORD tzid = GetTimeZoneInformation(&tz);
3619 int daylightBias =
3620 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias;
3621 sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3622 }
3623 return ret;
3624 }
3627 #define FT2INT64(ft) \
3628 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3631 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3632 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3633 // of a thread.
3634 //
3635 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3636 // the fast estimate available on the platform.
3638 // current_thread_cpu_time() is not optimized for Windows yet
3639 jlong os::current_thread_cpu_time() {
3640 // return user + sys since the cost is the same
3641 return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3642 }
3644 jlong os::thread_cpu_time(Thread* thread) {
3645 // consistent with what current_thread_cpu_time() returns.
3646 return os::thread_cpu_time(thread, true /* user+sys */);
3647 }
3649 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3650 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3651 }
3653 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3654 // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3655 // If this function changes, os::is_thread_cpu_time_supported() should too
3656 if (os::win32::is_nt()) {
3657 FILETIME CreationTime;
3658 FILETIME ExitTime;
3659 FILETIME KernelTime;
3660 FILETIME UserTime;
3662 if ( GetThreadTimes(thread->osthread()->thread_handle(),
3663 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3664 return -1;
3665 else
3666 if (user_sys_cpu_time) {
3667 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3668 } else {
3669 return FT2INT64(UserTime) * 100;
3670 }
3671 } else {
3672 return (jlong) timeGetTime() * 1000000;
3673 }
3674 }
3676 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3677 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3678 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3679 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3680 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3681 }
3683 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3684 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3685 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3686 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3687 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3688 }
3690 bool os::is_thread_cpu_time_supported() {
3691 // see os::thread_cpu_time
3692 if (os::win32::is_nt()) {
3693 FILETIME CreationTime;
3694 FILETIME ExitTime;
3695 FILETIME KernelTime;
3696 FILETIME UserTime;
3698 if ( GetThreadTimes(GetCurrentThread(),
3699 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3700 return false;
3701 else
3702 return true;
3703 } else {
3704 return false;
3705 }
3706 }
3708 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3709 // It does have primitives (PDH API) to get CPU usage and run queue length.
3710 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3711 // If we wanted to implement loadavg on Windows, we have a few options:
3712 //
3713 // a) Query CPU usage and run queue length and "fake" an answer by
3714 // returning the CPU usage if it's under 100%, and the run queue
3715 // length otherwise. It turns out that querying is pretty slow
3716 // on Windows, on the order of 200 microseconds on a fast machine.
3717 // Note that on the Windows the CPU usage value is the % usage
3718 // since the last time the API was called (and the first call
3719 // returns 100%), so we'd have to deal with that as well.
3720 //
3721 // b) Sample the "fake" answer using a sampling thread and store
3722 // the answer in a global variable. The call to loadavg would
3723 // just return the value of the global, avoiding the slow query.
3724 //
3725 // c) Sample a better answer using exponential decay to smooth the
3726 // value. This is basically the algorithm used by UNIX kernels.
3727 //
3728 // Note that sampling thread starvation could affect both (b) and (c).
3729 int os::loadavg(double loadavg[], int nelem) {
3730 return -1;
3731 }
3734 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3735 bool os::dont_yield() {
3736 return DontYieldALot;
3737 }
3739 // This method is a slightly reworked copy of JDK's sysOpen
3740 // from src/windows/hpi/src/sys_api_md.c
3742 int os::open(const char *path, int oflag, int mode) {
3743 char pathbuf[MAX_PATH];
3745 if (strlen(path) > MAX_PATH - 1) {
3746 errno = ENAMETOOLONG;
3747 return -1;
3748 }
3749 os::native_path(strcpy(pathbuf, path));
3750 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
3751 }
3753 // Is a (classpath) directory empty?
3754 bool os::dir_is_empty(const char* path) {
3755 WIN32_FIND_DATA fd;
3756 HANDLE f = FindFirstFile(path, &fd);
3757 if (f == INVALID_HANDLE_VALUE) {
3758 return true;
3759 }
3760 FindClose(f);
3761 return false;
3762 }
3764 // create binary file, rewriting existing file if required
3765 int os::create_binary_file(const char* path, bool rewrite_existing) {
3766 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
3767 if (!rewrite_existing) {
3768 oflags |= _O_EXCL;
3769 }
3770 return ::open(path, oflags, _S_IREAD | _S_IWRITE);
3771 }
3773 // return current position of file pointer
3774 jlong os::current_file_offset(int fd) {
3775 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
3776 }
3778 // move file pointer to the specified offset
3779 jlong os::seek_to_file_offset(int fd, jlong offset) {
3780 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
3781 }
3784 jlong os::lseek(int fd, jlong offset, int whence) {
3785 return (jlong) ::_lseeki64(fd, offset, whence);
3786 }
3788 // This method is a slightly reworked copy of JDK's sysNativePath
3789 // from src/windows/hpi/src/path_md.c
3791 /* Convert a pathname to native format. On win32, this involves forcing all
3792 separators to be '\\' rather than '/' (both are legal inputs, but Win95
3793 sometimes rejects '/') and removing redundant separators. The input path is
3794 assumed to have been converted into the character encoding used by the local
3795 system. Because this might be a double-byte encoding, care is taken to
3796 treat double-byte lead characters correctly.
3798 This procedure modifies the given path in place, as the result is never
3799 longer than the original. There is no error return; this operation always
3800 succeeds. */
3801 char * os::native_path(char *path) {
3802 char *src = path, *dst = path, *end = path;
3803 char *colon = NULL; /* If a drive specifier is found, this will
3804 point to the colon following the drive
3805 letter */
3807 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
3808 assert(((!::IsDBCSLeadByte('/'))
3809 && (!::IsDBCSLeadByte('\\'))
3810 && (!::IsDBCSLeadByte(':'))),
3811 "Illegal lead byte");
3813 /* Check for leading separators */
3814 #define isfilesep(c) ((c) == '/' || (c) == '\\')
3815 while (isfilesep(*src)) {
3816 src++;
3817 }
3819 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
3820 /* Remove leading separators if followed by drive specifier. This
3821 hack is necessary to support file URLs containing drive
3822 specifiers (e.g., "file://c:/path"). As a side effect,
3823 "/c:/path" can be used as an alternative to "c:/path". */
3824 *dst++ = *src++;
3825 colon = dst;
3826 *dst++ = ':';
3827 src++;
3828 } else {
3829 src = path;
3830 if (isfilesep(src[0]) && isfilesep(src[1])) {
3831 /* UNC pathname: Retain first separator; leave src pointed at
3832 second separator so that further separators will be collapsed
3833 into the second separator. The result will be a pathname
3834 beginning with "\\\\" followed (most likely) by a host name. */
3835 src = dst = path + 1;
3836 path[0] = '\\'; /* Force first separator to '\\' */
3837 }
3838 }
3840 end = dst;
3842 /* Remove redundant separators from remainder of path, forcing all
3843 separators to be '\\' rather than '/'. Also, single byte space
3844 characters are removed from the end of the path because those
3845 are not legal ending characters on this operating system.
3846 */
3847 while (*src != '\0') {
3848 if (isfilesep(*src)) {
3849 *dst++ = '\\'; src++;
3850 while (isfilesep(*src)) src++;
3851 if (*src == '\0') {
3852 /* Check for trailing separator */
3853 end = dst;
3854 if (colon == dst - 2) break; /* "z:\\" */
3855 if (dst == path + 1) break; /* "\\" */
3856 if (dst == path + 2 && isfilesep(path[0])) {
3857 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
3858 beginning of a UNC pathname. Even though it is not, by
3859 itself, a valid UNC pathname, we leave it as is in order
3860 to be consistent with the path canonicalizer as well
3861 as the win32 APIs, which treat this case as an invalid
3862 UNC pathname rather than as an alias for the root
3863 directory of the current drive. */
3864 break;
3865 }
3866 end = --dst; /* Path does not denote a root directory, so
3867 remove trailing separator */
3868 break;
3869 }
3870 end = dst;
3871 } else {
3872 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
3873 *dst++ = *src++;
3874 if (*src) *dst++ = *src++;
3875 end = dst;
3876 } else { /* Copy a single-byte character */
3877 char c = *src++;
3878 *dst++ = c;
3879 /* Space is not a legal ending character */
3880 if (c != ' ') end = dst;
3881 }
3882 }
3883 }
3885 *end = '\0';
3887 /* For "z:", add "." to work around a bug in the C runtime library */
3888 if (colon == dst - 1) {
3889 path[2] = '.';
3890 path[3] = '\0';
3891 }
3893 #ifdef DEBUG
3894 jio_fprintf(stderr, "sysNativePath: %s\n", path);
3895 #endif DEBUG
3896 return path;
3897 }
3899 // This code is a copy of JDK's sysSetLength
3900 // from src/windows/hpi/src/sys_api_md.c
3902 int os::ftruncate(int fd, jlong length) {
3903 HANDLE h = (HANDLE)::_get_osfhandle(fd);
3904 long high = (long)(length >> 32);
3905 DWORD ret;
3907 if (h == (HANDLE)(-1)) {
3908 return -1;
3909 }
3911 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
3912 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
3913 return -1;
3914 }
3916 if (::SetEndOfFile(h) == FALSE) {
3917 return -1;
3918 }
3920 return 0;
3921 }
3924 // This code is a copy of JDK's sysSync
3925 // from src/windows/hpi/src/sys_api_md.c
3926 // except for the legacy workaround for a bug in Win 98
3928 int os::fsync(int fd) {
3929 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
3931 if ( (!::FlushFileBuffers(handle)) &&
3932 (GetLastError() != ERROR_ACCESS_DENIED) ) {
3933 /* from winerror.h */
3934 return -1;
3935 }
3936 return 0;
3937 }
3939 static int nonSeekAvailable(int, long *);
3940 static int stdinAvailable(int, long *);
3942 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR)
3943 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO)
3945 // This code is a copy of JDK's sysAvailable
3946 // from src/windows/hpi/src/sys_api_md.c
3948 int os::available(int fd, jlong *bytes) {
3949 jlong cur, end;
3950 struct _stati64 stbuf64;
3952 if (::_fstati64(fd, &stbuf64) >= 0) {
3953 int mode = stbuf64.st_mode;
3954 if (S_ISCHR(mode) || S_ISFIFO(mode)) {
3955 int ret;
3956 long lpbytes;
3957 if (fd == 0) {
3958 ret = stdinAvailable(fd, &lpbytes);
3959 } else {
3960 ret = nonSeekAvailable(fd, &lpbytes);
3961 }
3962 (*bytes) = (jlong)(lpbytes);
3963 return ret;
3964 }
3965 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
3966 return FALSE;
3967 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
3968 return FALSE;
3969 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
3970 return FALSE;
3971 }
3972 *bytes = end - cur;
3973 return TRUE;
3974 } else {
3975 return FALSE;
3976 }
3977 }
3979 // This code is a copy of JDK's nonSeekAvailable
3980 // from src/windows/hpi/src/sys_api_md.c
3982 static int nonSeekAvailable(int fd, long *pbytes) {
3983 /* This is used for available on non-seekable devices
3984 * (like both named and anonymous pipes, such as pipes
3985 * connected to an exec'd process).
3986 * Standard Input is a special case.
3987 *
3988 */
3989 HANDLE han;
3991 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
3992 return FALSE;
3993 }
3995 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
3996 /* PeekNamedPipe fails when at EOF. In that case we
3997 * simply make *pbytes = 0 which is consistent with the
3998 * behavior we get on Solaris when an fd is at EOF.
3999 * The only alternative is to raise an Exception,
4000 * which isn't really warranted.
4001 */
4002 if (::GetLastError() != ERROR_BROKEN_PIPE) {
4003 return FALSE;
4004 }
4005 *pbytes = 0;
4006 }
4007 return TRUE;
4008 }
4010 #define MAX_INPUT_EVENTS 2000
4012 // This code is a copy of JDK's stdinAvailable
4013 // from src/windows/hpi/src/sys_api_md.c
4015 static int stdinAvailable(int fd, long *pbytes) {
4016 HANDLE han;
4017 DWORD numEventsRead = 0; /* Number of events read from buffer */
4018 DWORD numEvents = 0; /* Number of events in buffer */
4019 DWORD i = 0; /* Loop index */
4020 DWORD curLength = 0; /* Position marker */
4021 DWORD actualLength = 0; /* Number of bytes readable */
4022 BOOL error = FALSE; /* Error holder */
4023 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */
4025 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4026 return FALSE;
4027 }
4029 /* Construct an array of input records in the console buffer */
4030 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4031 if (error == 0) {
4032 return nonSeekAvailable(fd, pbytes);
4033 }
4035 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4036 if (numEvents > MAX_INPUT_EVENTS) {
4037 numEvents = MAX_INPUT_EVENTS;
4038 }
4040 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD));
4041 if (lpBuffer == NULL) {
4042 return FALSE;
4043 }
4045 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4046 if (error == 0) {
4047 os::free(lpBuffer);
4048 return FALSE;
4049 }
4051 /* Examine input records for the number of bytes available */
4052 for(i=0; i<numEvents; i++) {
4053 if (lpBuffer[i].EventType == KEY_EVENT) {
4055 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4056 &(lpBuffer[i].Event);
4057 if (keyRecord->bKeyDown == TRUE) {
4058 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4059 curLength++;
4060 if (*keyPressed == '\r') {
4061 actualLength = curLength;
4062 }
4063 }
4064 }
4065 }
4067 if(lpBuffer != NULL) {
4068 os::free(lpBuffer);
4069 }
4071 *pbytes = (long) actualLength;
4072 return TRUE;
4073 }
4075 // Map a block of memory.
4076 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
4077 char *addr, size_t bytes, bool read_only,
4078 bool allow_exec) {
4079 HANDLE hFile;
4080 char* base;
4082 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4083 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4084 if (hFile == NULL) {
4085 if (PrintMiscellaneous && Verbose) {
4086 DWORD err = GetLastError();
4087 tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4088 }
4089 return NULL;
4090 }
4092 if (allow_exec) {
4093 // CreateFileMapping/MapViewOfFileEx can't map executable memory
4094 // unless it comes from a PE image (which the shared archive is not.)
4095 // Even VirtualProtect refuses to give execute access to mapped memory
4096 // that was not previously executable.
4097 //
4098 // Instead, stick the executable region in anonymous memory. Yuck.
4099 // Penalty is that ~4 pages will not be shareable - in the future
4100 // we might consider DLLizing the shared archive with a proper PE
4101 // header so that mapping executable + sharing is possible.
4103 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4104 PAGE_READWRITE);
4105 if (base == NULL) {
4106 if (PrintMiscellaneous && Verbose) {
4107 DWORD err = GetLastError();
4108 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4109 }
4110 CloseHandle(hFile);
4111 return NULL;
4112 }
4114 DWORD bytes_read;
4115 OVERLAPPED overlapped;
4116 overlapped.Offset = (DWORD)file_offset;
4117 overlapped.OffsetHigh = 0;
4118 overlapped.hEvent = NULL;
4119 // ReadFile guarantees that if the return value is true, the requested
4120 // number of bytes were read before returning.
4121 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4122 if (!res) {
4123 if (PrintMiscellaneous && Verbose) {
4124 DWORD err = GetLastError();
4125 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4126 }
4127 release_memory(base, bytes);
4128 CloseHandle(hFile);
4129 return NULL;
4130 }
4131 } else {
4132 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4133 NULL /*file_name*/);
4134 if (hMap == NULL) {
4135 if (PrintMiscellaneous && Verbose) {
4136 DWORD err = GetLastError();
4137 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4138 }
4139 CloseHandle(hFile);
4140 return NULL;
4141 }
4143 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4144 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4145 (DWORD)bytes, addr);
4146 if (base == NULL) {
4147 if (PrintMiscellaneous && Verbose) {
4148 DWORD err = GetLastError();
4149 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4150 }
4151 CloseHandle(hMap);
4152 CloseHandle(hFile);
4153 return NULL;
4154 }
4156 if (CloseHandle(hMap) == 0) {
4157 if (PrintMiscellaneous && Verbose) {
4158 DWORD err = GetLastError();
4159 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4160 }
4161 CloseHandle(hFile);
4162 return base;
4163 }
4164 }
4166 if (allow_exec) {
4167 DWORD old_protect;
4168 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4169 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4171 if (!res) {
4172 if (PrintMiscellaneous && Verbose) {
4173 DWORD err = GetLastError();
4174 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4175 }
4176 // Don't consider this a hard error, on IA32 even if the
4177 // VirtualProtect fails, we should still be able to execute
4178 CloseHandle(hFile);
4179 return base;
4180 }
4181 }
4183 if (CloseHandle(hFile) == 0) {
4184 if (PrintMiscellaneous && Verbose) {
4185 DWORD err = GetLastError();
4186 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4187 }
4188 return base;
4189 }
4191 return base;
4192 }
4195 // Remap a block of memory.
4196 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
4197 char *addr, size_t bytes, bool read_only,
4198 bool allow_exec) {
4199 // This OS does not allow existing memory maps to be remapped so we
4200 // have to unmap the memory before we remap it.
4201 if (!os::unmap_memory(addr, bytes)) {
4202 return NULL;
4203 }
4205 // There is a very small theoretical window between the unmap_memory()
4206 // call above and the map_memory() call below where a thread in native
4207 // code may be able to access an address that is no longer mapped.
4209 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4210 allow_exec);
4211 }
4214 // Unmap a block of memory.
4215 // Returns true=success, otherwise false.
4217 bool os::unmap_memory(char* addr, size_t bytes) {
4218 BOOL result = UnmapViewOfFile(addr);
4219 if (result == 0) {
4220 if (PrintMiscellaneous && Verbose) {
4221 DWORD err = GetLastError();
4222 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4223 }
4224 return false;
4225 }
4226 return true;
4227 }
4229 void os::pause() {
4230 char filename[MAX_PATH];
4231 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4232 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4233 } else {
4234 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4235 }
4237 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4238 if (fd != -1) {
4239 struct stat buf;
4240 ::close(fd);
4241 while (::stat(filename, &buf) == 0) {
4242 Sleep(100);
4243 }
4244 } else {
4245 jio_fprintf(stderr,
4246 "Could not open pause file '%s', continuing immediately.\n", filename);
4247 }
4248 }
4250 // An Event wraps a win32 "CreateEvent" kernel handle.
4251 //
4252 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4253 //
4254 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4255 // field, and call CloseHandle() on the win32 event handle. Unpark() would
4256 // need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4257 // In addition, an unpark() operation might fetch the handle field, but the
4258 // event could recycle between the fetch and the SetEvent() operation.
4259 // SetEvent() would either fail because the handle was invalid, or inadvertently work,
4260 // as the win32 handle value had been recycled. In an ideal world calling SetEvent()
4261 // on an stale but recycled handle would be harmless, but in practice this might
4262 // confuse other non-Sun code, so it's not a viable approach.
4263 //
4264 // 2: Once a win32 event handle is associated with an Event, it remains associated
4265 // with the Event. The event handle is never closed. This could be construed
4266 // as handle leakage, but only up to the maximum # of threads that have been extant
4267 // at any one time. This shouldn't be an issue, as windows platforms typically
4268 // permit a process to have hundreds of thousands of open handles.
4269 //
4270 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4271 // and release unused handles.
4272 //
4273 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4274 // It's not clear, however, that we wouldn't be trading one type of leak for another.
4275 //
4276 // 5. Use an RCU-like mechanism (Read-Copy Update).
4277 // Or perhaps something similar to Maged Michael's "Hazard pointers".
4278 //
4279 // We use (2).
4280 //
4281 // TODO-FIXME:
4282 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4283 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4284 // to recover from (or at least detect) the dreaded Windows 841176 bug.
4285 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4286 // into a single win32 CreateEvent() handle.
4287 //
4288 // _Event transitions in park()
4289 // -1 => -1 : illegal
4290 // 1 => 0 : pass - return immediately
4291 // 0 => -1 : block
4292 //
4293 // _Event serves as a restricted-range semaphore :
4294 // -1 : thread is blocked
4295 // 0 : neutral - thread is running or ready
4296 // 1 : signaled - thread is running or ready
4297 //
4298 // Another possible encoding of _Event would be
4299 // with explicit "PARKED" and "SIGNALED" bits.
4301 int os::PlatformEvent::park (jlong Millis) {
4302 guarantee (_ParkHandle != NULL , "Invariant") ;
4303 guarantee (Millis > 0 , "Invariant") ;
4304 int v ;
4306 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4307 // the initial park() operation.
4309 for (;;) {
4310 v = _Event ;
4311 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4312 }
4313 guarantee ((v == 0) || (v == 1), "invariant") ;
4314 if (v != 0) return OS_OK ;
4316 // Do this the hard way by blocking ...
4317 // TODO: consider a brief spin here, gated on the success of recent
4318 // spin attempts by this thread.
4319 //
4320 // We decompose long timeouts into series of shorter timed waits.
4321 // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4322 // versions of Windows. See EventWait() for details. This may be superstition. Or not.
4323 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4324 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from
4325 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4326 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv ==
4327 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4328 // for the already waited time. This policy does not admit any new outcomes.
4329 // In the future, however, we might want to track the accumulated wait time and
4330 // adjust Millis accordingly if we encounter a spurious wakeup.
4332 const int MAXTIMEOUT = 0x10000000 ;
4333 DWORD rv = WAIT_TIMEOUT ;
4334 while (_Event < 0 && Millis > 0) {
4335 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT)
4336 if (Millis > MAXTIMEOUT) {
4337 prd = MAXTIMEOUT ;
4338 }
4339 rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4340 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4341 if (rv == WAIT_TIMEOUT) {
4342 Millis -= prd ;
4343 }
4344 }
4345 v = _Event ;
4346 _Event = 0 ;
4347 OrderAccess::fence() ;
4348 // If we encounter a nearly simultanous timeout expiry and unpark()
4349 // we return OS_OK indicating we awoke via unpark().
4350 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4351 return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4352 }
4354 void os::PlatformEvent::park () {
4355 guarantee (_ParkHandle != NULL, "Invariant") ;
4356 // Invariant: Only the thread associated with the Event/PlatformEvent
4357 // may call park().
4358 int v ;
4359 for (;;) {
4360 v = _Event ;
4361 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4362 }
4363 guarantee ((v == 0) || (v == 1), "invariant") ;
4364 if (v != 0) return ;
4366 // Do this the hard way by blocking ...
4367 // TODO: consider a brief spin here, gated on the success of recent
4368 // spin attempts by this thread.
4369 while (_Event < 0) {
4370 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4371 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4372 }
4374 // Usually we'll find _Event == 0 at this point, but as
4375 // an optional optimization we clear it, just in case can
4376 // multiple unpark() operations drove _Event up to 1.
4377 _Event = 0 ;
4378 OrderAccess::fence() ;
4379 guarantee (_Event >= 0, "invariant") ;
4380 }
4382 void os::PlatformEvent::unpark() {
4383 guarantee (_ParkHandle != NULL, "Invariant") ;
4384 int v ;
4385 for (;;) {
4386 v = _Event ; // Increment _Event if it's < 1.
4387 if (v > 0) {
4388 // If it's already signaled just return.
4389 // The LD of _Event could have reordered or be satisfied
4390 // by a read-aside from this processor's write buffer.
4391 // To avoid problems execute a barrier and then
4392 // ratify the value. A degenerate CAS() would also work.
4393 // Viz., CAS (v+0, &_Event, v) == v).
4394 OrderAccess::fence() ;
4395 if (_Event == v) return ;
4396 continue ;
4397 }
4398 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4399 }
4400 if (v < 0) {
4401 ::SetEvent (_ParkHandle) ;
4402 }
4403 }
4406 // JSR166
4407 // -------------------------------------------------------
4409 /*
4410 * The Windows implementation of Park is very straightforward: Basic
4411 * operations on Win32 Events turn out to have the right semantics to
4412 * use them directly. We opportunistically resuse the event inherited
4413 * from Monitor.
4414 */
4417 void Parker::park(bool isAbsolute, jlong time) {
4418 guarantee (_ParkEvent != NULL, "invariant") ;
4419 // First, demultiplex/decode time arguments
4420 if (time < 0) { // don't wait
4421 return;
4422 }
4423 else if (time == 0 && !isAbsolute) {
4424 time = INFINITE;
4425 }
4426 else if (isAbsolute) {
4427 time -= os::javaTimeMillis(); // convert to relative time
4428 if (time <= 0) // already elapsed
4429 return;
4430 }
4431 else { // relative
4432 time /= 1000000; // Must coarsen from nanos to millis
4433 if (time == 0) // Wait for the minimal time unit if zero
4434 time = 1;
4435 }
4437 JavaThread* thread = (JavaThread*)(Thread::current());
4438 assert(thread->is_Java_thread(), "Must be JavaThread");
4439 JavaThread *jt = (JavaThread *)thread;
4441 // Don't wait if interrupted or already triggered
4442 if (Thread::is_interrupted(thread, false) ||
4443 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4444 ResetEvent(_ParkEvent);
4445 return;
4446 }
4447 else {
4448 ThreadBlockInVM tbivm(jt);
4449 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4450 jt->set_suspend_equivalent();
4452 WaitForSingleObject(_ParkEvent, time);
4453 ResetEvent(_ParkEvent);
4455 // If externally suspended while waiting, re-suspend
4456 if (jt->handle_special_suspend_equivalent_condition()) {
4457 jt->java_suspend_self();
4458 }
4459 }
4460 }
4462 void Parker::unpark() {
4463 guarantee (_ParkEvent != NULL, "invariant") ;
4464 SetEvent(_ParkEvent);
4465 }
4467 // Run the specified command in a separate process. Return its exit value,
4468 // or -1 on failure (e.g. can't create a new process).
4469 int os::fork_and_exec(char* cmd) {
4470 STARTUPINFO si;
4471 PROCESS_INFORMATION pi;
4473 memset(&si, 0, sizeof(si));
4474 si.cb = sizeof(si);
4475 memset(&pi, 0, sizeof(pi));
4476 BOOL rslt = CreateProcess(NULL, // executable name - use command line
4477 cmd, // command line
4478 NULL, // process security attribute
4479 NULL, // thread security attribute
4480 TRUE, // inherits system handles
4481 0, // no creation flags
4482 NULL, // use parent's environment block
4483 NULL, // use parent's starting directory
4484 &si, // (in) startup information
4485 &pi); // (out) process information
4487 if (rslt) {
4488 // Wait until child process exits.
4489 WaitForSingleObject(pi.hProcess, INFINITE);
4491 DWORD exit_code;
4492 GetExitCodeProcess(pi.hProcess, &exit_code);
4494 // Close process and thread handles.
4495 CloseHandle(pi.hProcess);
4496 CloseHandle(pi.hThread);
4498 return (int)exit_code;
4499 } else {
4500 return -1;
4501 }
4502 }
4504 //--------------------------------------------------------------------------------------------------
4505 // Non-product code
4507 static int mallocDebugIntervalCounter = 0;
4508 static int mallocDebugCounter = 0;
4509 bool os::check_heap(bool force) {
4510 if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4511 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4512 // Note: HeapValidate executes two hardware breakpoints when it finds something
4513 // wrong; at these points, eax contains the address of the offending block (I think).
4514 // To get to the exlicit error message(s) below, just continue twice.
4515 HANDLE heap = GetProcessHeap();
4516 { HeapLock(heap);
4517 PROCESS_HEAP_ENTRY phe;
4518 phe.lpData = NULL;
4519 while (HeapWalk(heap, &phe) != 0) {
4520 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4521 !HeapValidate(heap, 0, phe.lpData)) {
4522 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4523 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4524 fatal("corrupted C heap");
4525 }
4526 }
4527 int err = GetLastError();
4528 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4529 fatal(err_msg("heap walk aborted with error %d", err));
4530 }
4531 HeapUnlock(heap);
4532 }
4533 mallocDebugIntervalCounter = 0;
4534 }
4535 return true;
4536 }
4539 bool os::find(address addr, outputStream* st) {
4540 // Nothing yet
4541 return false;
4542 }
4544 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4545 DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4547 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4548 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4549 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4550 address addr = (address) exceptionRecord->ExceptionInformation[1];
4552 if (os::is_memory_serialize_page(thread, addr))
4553 return EXCEPTION_CONTINUE_EXECUTION;
4554 }
4556 return EXCEPTION_CONTINUE_SEARCH;
4557 }
4559 static int getLastErrorString(char *buf, size_t len)
4560 {
4561 long errval;
4563 if ((errval = GetLastError()) != 0)
4564 {
4565 /* DOS error */
4566 size_t n = (size_t)FormatMessage(
4567 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
4568 NULL,
4569 errval,
4570 0,
4571 buf,
4572 (DWORD)len,
4573 NULL);
4574 if (n > 3) {
4575 /* Drop final '.', CR, LF */
4576 if (buf[n - 1] == '\n') n--;
4577 if (buf[n - 1] == '\r') n--;
4578 if (buf[n - 1] == '.') n--;
4579 buf[n] = '\0';
4580 }
4581 return (int)n;
4582 }
4584 if (errno != 0)
4585 {
4586 /* C runtime error that has no corresponding DOS error code */
4587 const char *s = strerror(errno);
4588 size_t n = strlen(s);
4589 if (n >= len) n = len - 1;
4590 strncpy(buf, s, n);
4591 buf[n] = '\0';
4592 return (int)n;
4593 }
4594 return 0;
4595 }
4598 // We don't build a headless jre for Windows
4599 bool os::is_headless_jre() { return false; }
4601 // OS_SocketInterface
4602 // Not used on Windows
4604 // OS_SocketInterface
4605 typedef struct hostent * (PASCAL FAR *ws2_ifn_ptr_t)(...);
4606 ws2_ifn_ptr_t *get_host_by_name_fn = NULL;
4608 typedef CRITICAL_SECTION mutex_t;
4609 #define mutexInit(m) InitializeCriticalSection(m)
4610 #define mutexDestroy(m) DeleteCriticalSection(m)
4611 #define mutexLock(m) EnterCriticalSection(m)
4612 #define mutexUnlock(m) LeaveCriticalSection(m)
4614 static bool sockfnptrs_initialized = FALSE;
4615 static mutex_t sockFnTableMutex;
4617 /* is Winsock2 loaded? better to be explicit than to rely on sockfnptrs */
4618 static bool winsock2Available = FALSE;
4621 static void initSockFnTable() {
4622 int (PASCAL FAR* WSAStartupPtr)(WORD, LPWSADATA);
4623 WSADATA wsadata;
4625 ::mutexInit(&sockFnTableMutex);
4626 ::mutexLock(&sockFnTableMutex);
4628 if (sockfnptrs_initialized == FALSE) {
4629 HMODULE hWinsock;
4631 /* try to load Winsock2, and if that fails, load Winsock */
4632 hWinsock = ::LoadLibrary("ws2_32.dll");
4634 if (hWinsock == NULL) {
4635 jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4636 ::GetLastError());
4637 return;
4638 }
4640 /* If we loaded a DLL, then we might as well initialize it. */
4641 WSAStartupPtr = (int (PASCAL FAR *)(WORD, LPWSADATA))
4642 ::GetProcAddress(hWinsock, "WSAStartup");
4644 if (WSAStartupPtr(MAKEWORD(1,1), &wsadata) != 0) {
4645 jio_fprintf(stderr, "Could not initialize Winsock\n");
4646 }
4648 get_host_by_name_fn
4649 = (ws2_ifn_ptr_t*) GetProcAddress(hWinsock, "gethostbyname");
4650 }
4652 assert(get_host_by_name_fn != NULL,
4653 "gethostbyname function not found");
4654 sockfnptrs_initialized = TRUE;
4655 ::mutexUnlock(&sockFnTableMutex);
4656 }
4658 struct hostent* os::get_host_by_name(char* name) {
4659 if (!sockfnptrs_initialized) {
4660 initSockFnTable();
4661 }
4663 assert(sockfnptrs_initialized == TRUE && get_host_by_name_fn != NULL,
4664 "sockfnptrs is not initialized or pointer to gethostbyname function is NULL");
4665 return (*get_host_by_name_fn)(name);
4666 }
4669 int os::socket_close(int fd) {
4670 ShouldNotReachHere();
4671 return 0;
4672 }
4674 int os::socket_available(int fd, jint *pbytes) {
4675 ShouldNotReachHere();
4676 return 0;
4677 }
4679 int os::socket(int domain, int type, int protocol) {
4680 ShouldNotReachHere();
4681 return 0;
4682 }
4684 int os::listen(int fd, int count) {
4685 ShouldNotReachHere();
4686 return 0;
4687 }
4689 int os::connect(int fd, struct sockaddr *him, int len) {
4690 ShouldNotReachHere();
4691 return 0;
4692 }
4694 int os::accept(int fd, struct sockaddr *him, int *len) {
4695 ShouldNotReachHere();
4696 return 0;
4697 }
4699 int os::sendto(int fd, char *buf, int len, int flags,
4700 struct sockaddr *to, int tolen) {
4701 ShouldNotReachHere();
4702 return 0;
4703 }
4705 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
4706 sockaddr *from, int *fromlen) {
4707 ShouldNotReachHere();
4708 return 0;
4709 }
4711 int os::recv(int fd, char *buf, int nBytes, int flags) {
4712 ShouldNotReachHere();
4713 return 0;
4714 }
4716 int os::send(int fd, char *buf, int nBytes, int flags) {
4717 ShouldNotReachHere();
4718 return 0;
4719 }
4721 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
4722 ShouldNotReachHere();
4723 return 0;
4724 }
4726 int os::timeout(int fd, long timeout) {
4727 ShouldNotReachHere();
4728 return 0;
4729 }
4731 int os::get_host_name(char* name, int namelen) {
4732 ShouldNotReachHere();
4733 return 0;
4734 }
4736 int os::socket_shutdown(int fd, int howto) {
4737 ShouldNotReachHere();
4738 return 0;
4739 }
4741 int os::bind(int fd, struct sockaddr *him, int len) {
4742 ShouldNotReachHere();
4743 return 0;
4744 }
4746 int os::get_sock_name(int fd, struct sockaddr *him, int *len) {
4747 ShouldNotReachHere();
4748 return 0;
4749 }
4751 int os::get_sock_opt(int fd, int level, int optname,
4752 char *optval, int* optlen) {
4753 ShouldNotReachHere();
4754 return 0;
4755 }
4757 int os::set_sock_opt(int fd, int level, int optname,
4758 const char *optval, int optlen) {
4759 ShouldNotReachHere();
4760 return 0;
4761 }