Sat, 11 Dec 2010 13:46:36 -0500
Merge
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 const char* os::get_temp_directory() {
1048 const char *prop = Arguments::get_property("java.io.tmpdir");
1049 if (prop != 0) return prop;
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 // ALT_JAVA_HOME or 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("ALT_JAVA_HOME");
1719 if (java_home_var == NULL) {
1720 java_home_var = ::getenv("JAVA_HOME");
1721 }
1722 if (java_home_var != NULL && java_home_var[0] != 0) {
1724 strncpy(buf, java_home_var, buflen);
1726 // determine if this is a legacy image or modules image
1727 // modules image doesn't have "jre" subdirectory
1728 size_t len = strlen(buf);
1729 char* jrebin_p = buf + len;
1730 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1731 if (0 != _access(buf, 0)) {
1732 jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1733 }
1734 len = strlen(buf);
1735 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1736 }
1737 }
1739 if(buf[0] == '\0') {
1740 GetModuleFileName(vm_lib_handle, buf, buflen);
1741 }
1742 strcpy(saved_jvm_path, buf);
1743 }
1746 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1747 #ifndef _WIN64
1748 st->print("_");
1749 #endif
1750 }
1753 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1754 #ifndef _WIN64
1755 st->print("@%d", args_size * sizeof(int));
1756 #endif
1757 }
1759 // This method is a copy of JDK's sysGetLastErrorString
1760 // from src/windows/hpi/src/system_md.c
1762 size_t os::lasterror(char *buf, size_t len) {
1763 long errval;
1765 if ((errval = GetLastError()) != 0) {
1766 /* DOS error */
1767 int n = (int)FormatMessage(
1768 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1769 NULL,
1770 errval,
1771 0,
1772 buf,
1773 (DWORD)len,
1774 NULL);
1775 if (n > 3) {
1776 /* Drop final '.', CR, LF */
1777 if (buf[n - 1] == '\n') n--;
1778 if (buf[n - 1] == '\r') n--;
1779 if (buf[n - 1] == '.') n--;
1780 buf[n] = '\0';
1781 }
1782 return n;
1783 }
1785 if (errno != 0) {
1786 /* C runtime error that has no corresponding DOS error code */
1787 const char *s = strerror(errno);
1788 size_t n = strlen(s);
1789 if (n >= len) n = len - 1;
1790 strncpy(buf, s, n);
1791 buf[n] = '\0';
1792 return n;
1793 }
1794 return 0;
1795 }
1797 // sun.misc.Signal
1798 // NOTE that this is a workaround for an apparent kernel bug where if
1799 // a signal handler for SIGBREAK is installed then that signal handler
1800 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1801 // See bug 4416763.
1802 static void (*sigbreakHandler)(int) = NULL;
1804 static void UserHandler(int sig, void *siginfo, void *context) {
1805 os::signal_notify(sig);
1806 // We need to reinstate the signal handler each time...
1807 os::signal(sig, (void*)UserHandler);
1808 }
1810 void* os::user_handler() {
1811 return (void*) UserHandler;
1812 }
1814 void* os::signal(int signal_number, void* handler) {
1815 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1816 void (*oldHandler)(int) = sigbreakHandler;
1817 sigbreakHandler = (void (*)(int)) handler;
1818 return (void*) oldHandler;
1819 } else {
1820 return (void*)::signal(signal_number, (void (*)(int))handler);
1821 }
1822 }
1824 void os::signal_raise(int signal_number) {
1825 raise(signal_number);
1826 }
1828 // The Win32 C runtime library maps all console control events other than ^C
1829 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1830 // logoff, and shutdown events. We therefore install our own console handler
1831 // that raises SIGTERM for the latter cases.
1832 //
1833 static BOOL WINAPI consoleHandler(DWORD event) {
1834 switch(event) {
1835 case CTRL_C_EVENT:
1836 if (is_error_reported()) {
1837 // Ctrl-C is pressed during error reporting, likely because the error
1838 // handler fails to abort. Let VM die immediately.
1839 os::die();
1840 }
1842 os::signal_raise(SIGINT);
1843 return TRUE;
1844 break;
1845 case CTRL_BREAK_EVENT:
1846 if (sigbreakHandler != NULL) {
1847 (*sigbreakHandler)(SIGBREAK);
1848 }
1849 return TRUE;
1850 break;
1851 case CTRL_CLOSE_EVENT:
1852 case CTRL_LOGOFF_EVENT:
1853 case CTRL_SHUTDOWN_EVENT:
1854 os::signal_raise(SIGTERM);
1855 return TRUE;
1856 break;
1857 default:
1858 break;
1859 }
1860 return FALSE;
1861 }
1863 /*
1864 * The following code is moved from os.cpp for making this
1865 * code platform specific, which it is by its very nature.
1866 */
1868 // Return maximum OS signal used + 1 for internal use only
1869 // Used as exit signal for signal_thread
1870 int os::sigexitnum_pd(){
1871 return NSIG;
1872 }
1874 // a counter for each possible signal value, including signal_thread exit signal
1875 static volatile jint pending_signals[NSIG+1] = { 0 };
1876 static HANDLE sig_sem;
1878 void os::signal_init_pd() {
1879 // Initialize signal structures
1880 memset((void*)pending_signals, 0, sizeof(pending_signals));
1882 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
1884 // Programs embedding the VM do not want it to attempt to receive
1885 // events like CTRL_LOGOFF_EVENT, which are used to implement the
1886 // shutdown hooks mechanism introduced in 1.3. For example, when
1887 // the VM is run as part of a Windows NT service (i.e., a servlet
1888 // engine in a web server), the correct behavior is for any console
1889 // control handler to return FALSE, not TRUE, because the OS's
1890 // "final" handler for such events allows the process to continue if
1891 // it is a service (while terminating it if it is not a service).
1892 // To make this behavior uniform and the mechanism simpler, we
1893 // completely disable the VM's usage of these console events if -Xrs
1894 // (=ReduceSignalUsage) is specified. This means, for example, that
1895 // the CTRL-BREAK thread dump mechanism is also disabled in this
1896 // case. See bugs 4323062, 4345157, and related bugs.
1898 if (!ReduceSignalUsage) {
1899 // Add a CTRL-C handler
1900 SetConsoleCtrlHandler(consoleHandler, TRUE);
1901 }
1902 }
1904 void os::signal_notify(int signal_number) {
1905 BOOL ret;
1907 Atomic::inc(&pending_signals[signal_number]);
1908 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1909 assert(ret != 0, "ReleaseSemaphore() failed");
1910 }
1912 static int check_pending_signals(bool wait_for_signal) {
1913 DWORD ret;
1914 while (true) {
1915 for (int i = 0; i < NSIG + 1; i++) {
1916 jint n = pending_signals[i];
1917 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1918 return i;
1919 }
1920 }
1921 if (!wait_for_signal) {
1922 return -1;
1923 }
1925 JavaThread *thread = JavaThread::current();
1927 ThreadBlockInVM tbivm(thread);
1929 bool threadIsSuspended;
1930 do {
1931 thread->set_suspend_equivalent();
1932 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1933 ret = ::WaitForSingleObject(sig_sem, INFINITE);
1934 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
1936 // were we externally suspended while we were waiting?
1937 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1938 if (threadIsSuspended) {
1939 //
1940 // The semaphore has been incremented, but while we were waiting
1941 // another thread suspended us. We don't want to continue running
1942 // while suspended because that would surprise the thread that
1943 // suspended us.
1944 //
1945 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
1946 assert(ret != 0, "ReleaseSemaphore() failed");
1948 thread->java_suspend_self();
1949 }
1950 } while (threadIsSuspended);
1951 }
1952 }
1954 int os::signal_lookup() {
1955 return check_pending_signals(false);
1956 }
1958 int os::signal_wait() {
1959 return check_pending_signals(true);
1960 }
1962 // Implicit OS exception handling
1964 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
1965 JavaThread* thread = JavaThread::current();
1966 // Save pc in thread
1967 #ifdef _M_IA64
1968 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
1969 // Set pc to handler
1970 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
1971 #elif _M_AMD64
1972 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
1973 // Set pc to handler
1974 exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
1975 #else
1976 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
1977 // Set pc to handler
1978 exceptionInfo->ContextRecord->Eip = (LONG)handler;
1979 #endif
1981 // Continue the execution
1982 return EXCEPTION_CONTINUE_EXECUTION;
1983 }
1986 // Used for PostMortemDump
1987 extern "C" void safepoints();
1988 extern "C" void find(int x);
1989 extern "C" void events();
1991 // According to Windows API documentation, an illegal instruction sequence should generate
1992 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
1993 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
1994 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
1996 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
1998 // From "Execution Protection in the Windows Operating System" draft 0.35
1999 // Once a system header becomes available, the "real" define should be
2000 // included or copied here.
2001 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2003 #define def_excpt(val) #val, val
2005 struct siglabel {
2006 char *name;
2007 int number;
2008 };
2010 struct siglabel exceptlabels[] = {
2011 def_excpt(EXCEPTION_ACCESS_VIOLATION),
2012 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2013 def_excpt(EXCEPTION_BREAKPOINT),
2014 def_excpt(EXCEPTION_SINGLE_STEP),
2015 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2016 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2017 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2018 def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2019 def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2020 def_excpt(EXCEPTION_FLT_OVERFLOW),
2021 def_excpt(EXCEPTION_FLT_STACK_CHECK),
2022 def_excpt(EXCEPTION_FLT_UNDERFLOW),
2023 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2024 def_excpt(EXCEPTION_INT_OVERFLOW),
2025 def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2026 def_excpt(EXCEPTION_IN_PAGE_ERROR),
2027 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2028 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2029 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2030 def_excpt(EXCEPTION_STACK_OVERFLOW),
2031 def_excpt(EXCEPTION_INVALID_DISPOSITION),
2032 def_excpt(EXCEPTION_GUARD_PAGE),
2033 def_excpt(EXCEPTION_INVALID_HANDLE),
2034 NULL, 0
2035 };
2037 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2038 for (int i = 0; exceptlabels[i].name != NULL; i++) {
2039 if (exceptlabels[i].number == exception_code) {
2040 jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2041 return buf;
2042 }
2043 }
2045 return NULL;
2046 }
2048 //-----------------------------------------------------------------------------
2049 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2050 // handle exception caused by idiv; should only happen for -MinInt/-1
2051 // (division by zero is handled explicitly)
2052 #ifdef _M_IA64
2053 assert(0, "Fix Handle_IDiv_Exception");
2054 #elif _M_AMD64
2055 PCONTEXT ctx = exceptionInfo->ContextRecord;
2056 address pc = (address)ctx->Rip;
2057 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2058 assert(pc[0] == 0xF7, "not an idiv opcode");
2059 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2060 assert(ctx->Rax == min_jint, "unexpected idiv exception");
2061 // set correct result values and continue after idiv instruction
2062 ctx->Rip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2063 ctx->Rax = (DWORD)min_jint; // result
2064 ctx->Rdx = (DWORD)0; // remainder
2065 // Continue the execution
2066 #else
2067 PCONTEXT ctx = exceptionInfo->ContextRecord;
2068 address pc = (address)ctx->Eip;
2069 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2070 assert(pc[0] == 0xF7, "not an idiv opcode");
2071 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2072 assert(ctx->Eax == min_jint, "unexpected idiv exception");
2073 // set correct result values and continue after idiv instruction
2074 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2075 ctx->Eax = (DWORD)min_jint; // result
2076 ctx->Edx = (DWORD)0; // remainder
2077 // Continue the execution
2078 #endif
2079 return EXCEPTION_CONTINUE_EXECUTION;
2080 }
2082 #ifndef _WIN64
2083 //-----------------------------------------------------------------------------
2084 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2085 // handle exception caused by native method modifying control word
2086 PCONTEXT ctx = exceptionInfo->ContextRecord;
2087 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2089 switch (exception_code) {
2090 case EXCEPTION_FLT_DENORMAL_OPERAND:
2091 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2092 case EXCEPTION_FLT_INEXACT_RESULT:
2093 case EXCEPTION_FLT_INVALID_OPERATION:
2094 case EXCEPTION_FLT_OVERFLOW:
2095 case EXCEPTION_FLT_STACK_CHECK:
2096 case EXCEPTION_FLT_UNDERFLOW:
2097 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2098 if (fp_control_word != ctx->FloatSave.ControlWord) {
2099 // Restore FPCW and mask out FLT exceptions
2100 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2101 // Mask out pending FLT exceptions
2102 ctx->FloatSave.StatusWord &= 0xffffff00;
2103 return EXCEPTION_CONTINUE_EXECUTION;
2104 }
2105 }
2107 if (prev_uef_handler != NULL) {
2108 // We didn't handle this exception so pass it to the previous
2109 // UnhandledExceptionFilter.
2110 return (prev_uef_handler)(exceptionInfo);
2111 }
2113 return EXCEPTION_CONTINUE_SEARCH;
2114 }
2115 #else //_WIN64
2116 /*
2117 On Windows, the mxcsr control bits are non-volatile across calls
2118 See also CR 6192333
2119 If EXCEPTION_FLT_* happened after some native method modified
2120 mxcsr - it is not a jvm fault.
2121 However should we decide to restore of mxcsr after a faulty
2122 native method we can uncomment following code
2123 jint MxCsr = INITIAL_MXCSR;
2124 // we can't use StubRoutines::addr_mxcsr_std()
2125 // because in Win64 mxcsr is not saved there
2126 if (MxCsr != ctx->MxCsr) {
2127 ctx->MxCsr = MxCsr;
2128 return EXCEPTION_CONTINUE_EXECUTION;
2129 }
2131 */
2132 #endif //_WIN64
2135 // Fatal error reporting is single threaded so we can make this a
2136 // static and preallocated. If it's more than MAX_PATH silently ignore
2137 // it.
2138 static char saved_error_file[MAX_PATH] = {0};
2140 void os::set_error_file(const char *logfile) {
2141 if (strlen(logfile) <= MAX_PATH) {
2142 strncpy(saved_error_file, logfile, MAX_PATH);
2143 }
2144 }
2146 static inline void report_error(Thread* t, DWORD exception_code,
2147 address addr, void* siginfo, void* context) {
2148 VMError err(t, exception_code, addr, siginfo, context);
2149 err.report_and_die();
2151 // If UseOsErrorReporting, this will return here and save the error file
2152 // somewhere where we can find it in the minidump.
2153 }
2155 //-----------------------------------------------------------------------------
2156 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2157 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2158 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2159 #ifdef _M_IA64
2160 address pc = (address) exceptionInfo->ContextRecord->StIIP;
2161 #elif _M_AMD64
2162 address pc = (address) exceptionInfo->ContextRecord->Rip;
2163 #else
2164 address pc = (address) exceptionInfo->ContextRecord->Eip;
2165 #endif
2166 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady
2168 #ifndef _WIN64
2169 // Execution protection violation - win32 running on AMD64 only
2170 // Handled first to avoid misdiagnosis as a "normal" access violation;
2171 // This is safe to do because we have a new/unique ExceptionInformation
2172 // code for this condition.
2173 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2174 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2175 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2176 address addr = (address) exceptionRecord->ExceptionInformation[1];
2178 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2179 int page_size = os::vm_page_size();
2181 // Make sure the pc and the faulting address are sane.
2182 //
2183 // If an instruction spans a page boundary, and the page containing
2184 // the beginning of the instruction is executable but the following
2185 // page is not, the pc and the faulting address might be slightly
2186 // different - we still want to unguard the 2nd page in this case.
2187 //
2188 // 15 bytes seems to be a (very) safe value for max instruction size.
2189 bool pc_is_near_addr =
2190 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2191 bool instr_spans_page_boundary =
2192 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2193 (intptr_t) page_size) > 0);
2195 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2196 static volatile address last_addr =
2197 (address) os::non_memory_address_word();
2199 // In conservative mode, don't unguard unless the address is in the VM
2200 if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2201 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2203 // Set memory to RWX and retry
2204 address page_start =
2205 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2206 bool res = os::protect_memory((char*) page_start, page_size,
2207 os::MEM_PROT_RWX);
2209 if (PrintMiscellaneous && Verbose) {
2210 char buf[256];
2211 jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2212 "at " INTPTR_FORMAT
2213 ", unguarding " INTPTR_FORMAT ": %s", addr,
2214 page_start, (res ? "success" : strerror(errno)));
2215 tty->print_raw_cr(buf);
2216 }
2218 // Set last_addr so if we fault again at the same address, we don't
2219 // end up in an endless loop.
2220 //
2221 // There are two potential complications here. Two threads trapping
2222 // at the same address at the same time could cause one of the
2223 // threads to think it already unguarded, and abort the VM. Likely
2224 // very rare.
2225 //
2226 // The other race involves two threads alternately trapping at
2227 // different addresses and failing to unguard the page, resulting in
2228 // an endless loop. This condition is probably even more unlikely
2229 // than the first.
2230 //
2231 // Although both cases could be avoided by using locks or thread
2232 // local last_addr, these solutions are unnecessary complication:
2233 // this handler is a best-effort safety net, not a complete solution.
2234 // It is disabled by default and should only be used as a workaround
2235 // in case we missed any no-execute-unsafe VM code.
2237 last_addr = addr;
2239 return EXCEPTION_CONTINUE_EXECUTION;
2240 }
2241 }
2243 // Last unguard failed or not unguarding
2244 tty->print_raw_cr("Execution protection violation");
2245 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2246 exceptionInfo->ContextRecord);
2247 return EXCEPTION_CONTINUE_SEARCH;
2248 }
2249 }
2250 #endif // _WIN64
2252 // Check to see if we caught the safepoint code in the
2253 // process of write protecting the memory serialization page.
2254 // It write enables the page immediately after protecting it
2255 // so just return.
2256 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2257 JavaThread* thread = (JavaThread*) t;
2258 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2259 address addr = (address) exceptionRecord->ExceptionInformation[1];
2260 if ( os::is_memory_serialize_page(thread, addr) ) {
2261 // Block current thread until the memory serialize page permission restored.
2262 os::block_on_serialize_page_trap();
2263 return EXCEPTION_CONTINUE_EXECUTION;
2264 }
2265 }
2268 if (t != NULL && t->is_Java_thread()) {
2269 JavaThread* thread = (JavaThread*) t;
2270 bool in_java = thread->thread_state() == _thread_in_Java;
2272 // Handle potential stack overflows up front.
2273 if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2274 if (os::uses_stack_guard_pages()) {
2275 #ifdef _M_IA64
2276 //
2277 // If it's a legal stack address continue, Windows will map it in.
2278 //
2279 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2280 address addr = (address) exceptionRecord->ExceptionInformation[1];
2281 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2282 return EXCEPTION_CONTINUE_EXECUTION;
2284 // The register save area is the same size as the memory stack
2285 // and starts at the page just above the start of the memory stack.
2286 // If we get a fault in this area, we've run out of register
2287 // stack. If we are in java, try throwing a stack overflow exception.
2288 if (addr > thread->stack_base() &&
2289 addr <= (thread->stack_base()+thread->stack_size()) ) {
2290 char buf[256];
2291 jio_snprintf(buf, sizeof(buf),
2292 "Register stack overflow, addr:%p, stack_base:%p\n",
2293 addr, thread->stack_base() );
2294 tty->print_raw_cr(buf);
2295 // If not in java code, return and hope for the best.
2296 return in_java ? Handle_Exception(exceptionInfo,
2297 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2298 : EXCEPTION_CONTINUE_EXECUTION;
2299 }
2300 #endif
2301 if (thread->stack_yellow_zone_enabled()) {
2302 // Yellow zone violation. The o/s has unprotected the first yellow
2303 // zone page for us. Note: must call disable_stack_yellow_zone to
2304 // update the enabled status, even if the zone contains only one page.
2305 thread->disable_stack_yellow_zone();
2306 // If not in java code, return and hope for the best.
2307 return in_java ? Handle_Exception(exceptionInfo,
2308 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2309 : EXCEPTION_CONTINUE_EXECUTION;
2310 } else {
2311 // Fatal red zone violation.
2312 thread->disable_stack_red_zone();
2313 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2314 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2315 exceptionInfo->ContextRecord);
2316 return EXCEPTION_CONTINUE_SEARCH;
2317 }
2318 } else if (in_java) {
2319 // JVM-managed guard pages cannot be used on win95/98. The o/s provides
2320 // a one-time-only guard page, which it has released to us. The next
2321 // stack overflow on this thread will result in an ACCESS_VIOLATION.
2322 return Handle_Exception(exceptionInfo,
2323 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2324 } else {
2325 // Can only return and hope for the best. Further stack growth will
2326 // result in an ACCESS_VIOLATION.
2327 return EXCEPTION_CONTINUE_EXECUTION;
2328 }
2329 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2330 // Either stack overflow or null pointer exception.
2331 if (in_java) {
2332 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2333 address addr = (address) exceptionRecord->ExceptionInformation[1];
2334 address stack_end = thread->stack_base() - thread->stack_size();
2335 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2336 // Stack overflow.
2337 assert(!os::uses_stack_guard_pages(),
2338 "should be caught by red zone code above.");
2339 return Handle_Exception(exceptionInfo,
2340 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2341 }
2342 //
2343 // Check for safepoint polling and implicit null
2344 // We only expect null pointers in the stubs (vtable)
2345 // the rest are checked explicitly now.
2346 //
2347 CodeBlob* cb = CodeCache::find_blob(pc);
2348 if (cb != NULL) {
2349 if (os::is_poll_address(addr)) {
2350 address stub = SharedRuntime::get_poll_stub(pc);
2351 return Handle_Exception(exceptionInfo, stub);
2352 }
2353 }
2354 {
2355 #ifdef _WIN64
2356 //
2357 // If it's a legal stack address map the entire region in
2358 //
2359 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2360 address addr = (address) exceptionRecord->ExceptionInformation[1];
2361 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2362 addr = (address)((uintptr_t)addr &
2363 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2364 os::commit_memory((char *)addr, thread->stack_base() - addr,
2365 false );
2366 return EXCEPTION_CONTINUE_EXECUTION;
2367 }
2368 else
2369 #endif
2370 {
2371 // Null pointer exception.
2372 #ifdef _M_IA64
2373 // We catch register stack overflows in compiled code by doing
2374 // an explicit compare and executing a st8(G0, G0) if the
2375 // BSP enters into our guard area. We test for the overflow
2376 // condition and fall into the normal null pointer exception
2377 // code if BSP hasn't overflowed.
2378 if ( in_java ) {
2379 if(thread->register_stack_overflow()) {
2380 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2381 thread->register_stack_limit(),
2382 "GR7 doesn't contain register_stack_limit");
2383 // Disable the yellow zone which sets the state that
2384 // we've got a stack overflow problem.
2385 if (thread->stack_yellow_zone_enabled()) {
2386 thread->disable_stack_yellow_zone();
2387 }
2388 // Give us some room to process the exception
2389 thread->disable_register_stack_guard();
2390 // Update GR7 with the new limit so we can continue running
2391 // compiled code.
2392 exceptionInfo->ContextRecord->IntS3 =
2393 (ULONGLONG)thread->register_stack_limit();
2394 return Handle_Exception(exceptionInfo,
2395 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2396 } else {
2397 //
2398 // Check for implicit null
2399 // We only expect null pointers in the stubs (vtable)
2400 // the rest are checked explicitly now.
2401 //
2402 if (((uintptr_t)addr) < os::vm_page_size() ) {
2403 // an access to the first page of VM--assume it is a null pointer
2404 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2405 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2406 }
2407 }
2408 } // in_java
2410 // IA64 doesn't use implicit null checking yet. So we shouldn't
2411 // get here.
2412 tty->print_raw_cr("Access violation, possible null pointer exception");
2413 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2414 exceptionInfo->ContextRecord);
2415 return EXCEPTION_CONTINUE_SEARCH;
2416 #else /* !IA64 */
2418 // Windows 98 reports faulting addresses incorrectly
2419 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2420 !os::win32::is_nt()) {
2421 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2422 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2423 }
2424 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2425 exceptionInfo->ContextRecord);
2426 return EXCEPTION_CONTINUE_SEARCH;
2427 #endif
2428 }
2429 }
2430 }
2432 #ifdef _WIN64
2433 // Special care for fast JNI field accessors.
2434 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2435 // in and the heap gets shrunk before the field access.
2436 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2437 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2438 if (addr != (address)-1) {
2439 return Handle_Exception(exceptionInfo, addr);
2440 }
2441 }
2442 #endif
2444 #ifdef _WIN64
2445 // Windows will sometimes generate an access violation
2446 // when we call malloc. Since we use VectoredExceptions
2447 // on 64 bit platforms, we see this exception. We must
2448 // pass this exception on so Windows can recover.
2449 // We check to see if the pc of the fault is in NTDLL.DLL
2450 // if so, we pass control on to Windows for handling.
2451 if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2452 #endif
2454 // Stack overflow or null pointer exception in native code.
2455 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2456 exceptionInfo->ContextRecord);
2457 return EXCEPTION_CONTINUE_SEARCH;
2458 }
2460 if (in_java) {
2461 switch (exception_code) {
2462 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2463 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2465 case EXCEPTION_INT_OVERFLOW:
2466 return Handle_IDiv_Exception(exceptionInfo);
2468 } // switch
2469 }
2470 #ifndef _WIN64
2471 if ((thread->thread_state() == _thread_in_Java) ||
2472 (thread->thread_state() == _thread_in_native) )
2473 {
2474 LONG result=Handle_FLT_Exception(exceptionInfo);
2475 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2476 }
2477 #endif //_WIN64
2478 }
2480 if (exception_code != EXCEPTION_BREAKPOINT) {
2481 #ifndef _WIN64
2482 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2483 exceptionInfo->ContextRecord);
2484 #else
2485 // Itanium Windows uses a VectoredExceptionHandler
2486 // Which means that C++ programatic exception handlers (try/except)
2487 // will get here. Continue the search for the right except block if
2488 // the exception code is not a fatal code.
2489 switch ( exception_code ) {
2490 case EXCEPTION_ACCESS_VIOLATION:
2491 case EXCEPTION_STACK_OVERFLOW:
2492 case EXCEPTION_ILLEGAL_INSTRUCTION:
2493 case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2494 case EXCEPTION_INT_OVERFLOW:
2495 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2496 { report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2497 exceptionInfo->ContextRecord);
2498 }
2499 break;
2500 default:
2501 break;
2502 }
2503 #endif
2504 }
2505 return EXCEPTION_CONTINUE_SEARCH;
2506 }
2508 #ifndef _WIN64
2509 // Special care for fast JNI accessors.
2510 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2511 // the heap gets shrunk before the field access.
2512 // Need to install our own structured exception handler since native code may
2513 // install its own.
2514 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2515 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2516 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2517 address pc = (address) exceptionInfo->ContextRecord->Eip;
2518 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2519 if (addr != (address)-1) {
2520 return Handle_Exception(exceptionInfo, addr);
2521 }
2522 }
2523 return EXCEPTION_CONTINUE_SEARCH;
2524 }
2526 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2527 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2528 __try { \
2529 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2530 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2531 } \
2532 return 0; \
2533 }
2535 DEFINE_FAST_GETFIELD(jboolean, bool, Boolean)
2536 DEFINE_FAST_GETFIELD(jbyte, byte, Byte)
2537 DEFINE_FAST_GETFIELD(jchar, char, Char)
2538 DEFINE_FAST_GETFIELD(jshort, short, Short)
2539 DEFINE_FAST_GETFIELD(jint, int, Int)
2540 DEFINE_FAST_GETFIELD(jlong, long, Long)
2541 DEFINE_FAST_GETFIELD(jfloat, float, Float)
2542 DEFINE_FAST_GETFIELD(jdouble, double, Double)
2544 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2545 switch (type) {
2546 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2547 case T_BYTE: return (address)jni_fast_GetByteField_wrapper;
2548 case T_CHAR: return (address)jni_fast_GetCharField_wrapper;
2549 case T_SHORT: return (address)jni_fast_GetShortField_wrapper;
2550 case T_INT: return (address)jni_fast_GetIntField_wrapper;
2551 case T_LONG: return (address)jni_fast_GetLongField_wrapper;
2552 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper;
2553 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper;
2554 default: ShouldNotReachHere();
2555 }
2556 return (address)-1;
2557 }
2558 #endif
2560 // Virtual Memory
2562 int os::vm_page_size() { return os::win32::vm_page_size(); }
2563 int os::vm_allocation_granularity() {
2564 return os::win32::vm_allocation_granularity();
2565 }
2567 // Windows large page support is available on Windows 2003. In order to use
2568 // large page memory, the administrator must first assign additional privilege
2569 // to the user:
2570 // + select Control Panel -> Administrative Tools -> Local Security Policy
2571 // + select Local Policies -> User Rights Assignment
2572 // + double click "Lock pages in memory", add users and/or groups
2573 // + reboot
2574 // Note the above steps are needed for administrator as well, as administrators
2575 // by default do not have the privilege to lock pages in memory.
2576 //
2577 // Note about Windows 2003: although the API supports committing large page
2578 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2579 // scenario, I found through experiment it only uses large page if the entire
2580 // memory region is reserved and committed in a single VirtualAlloc() call.
2581 // This makes Windows large page support more or less like Solaris ISM, in
2582 // that the entire heap must be committed upfront. This probably will change
2583 // in the future, if so the code below needs to be revisited.
2585 #ifndef MEM_LARGE_PAGES
2586 #define MEM_LARGE_PAGES 0x20000000
2587 #endif
2589 // GetLargePageMinimum is only available on Windows 2003. The other functions
2590 // are available on NT but not on Windows 98/Me. We have to resolve them at
2591 // runtime.
2592 typedef SIZE_T (WINAPI *GetLargePageMinimum_func_type) (void);
2593 typedef BOOL (WINAPI *AdjustTokenPrivileges_func_type)
2594 (HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
2595 typedef BOOL (WINAPI *OpenProcessToken_func_type) (HANDLE, DWORD, PHANDLE);
2596 typedef BOOL (WINAPI *LookupPrivilegeValue_func_type) (LPCTSTR, LPCTSTR, PLUID);
2598 static GetLargePageMinimum_func_type _GetLargePageMinimum;
2599 static AdjustTokenPrivileges_func_type _AdjustTokenPrivileges;
2600 static OpenProcessToken_func_type _OpenProcessToken;
2601 static LookupPrivilegeValue_func_type _LookupPrivilegeValue;
2603 static HINSTANCE _kernel32;
2604 static HINSTANCE _advapi32;
2605 static HANDLE _hProcess;
2606 static HANDLE _hToken;
2608 static size_t _large_page_size = 0;
2610 static bool resolve_functions_for_large_page_init() {
2611 _kernel32 = LoadLibrary("kernel32.dll");
2612 if (_kernel32 == NULL) return false;
2614 _GetLargePageMinimum = CAST_TO_FN_PTR(GetLargePageMinimum_func_type,
2615 GetProcAddress(_kernel32, "GetLargePageMinimum"));
2616 if (_GetLargePageMinimum == NULL) return false;
2618 _advapi32 = LoadLibrary("advapi32.dll");
2619 if (_advapi32 == NULL) return false;
2621 _AdjustTokenPrivileges = CAST_TO_FN_PTR(AdjustTokenPrivileges_func_type,
2622 GetProcAddress(_advapi32, "AdjustTokenPrivileges"));
2623 _OpenProcessToken = CAST_TO_FN_PTR(OpenProcessToken_func_type,
2624 GetProcAddress(_advapi32, "OpenProcessToken"));
2625 _LookupPrivilegeValue = CAST_TO_FN_PTR(LookupPrivilegeValue_func_type,
2626 GetProcAddress(_advapi32, "LookupPrivilegeValueA"));
2627 return _AdjustTokenPrivileges != NULL &&
2628 _OpenProcessToken != NULL &&
2629 _LookupPrivilegeValue != NULL;
2630 }
2632 static bool request_lock_memory_privilege() {
2633 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2634 os::current_process_id());
2636 LUID luid;
2637 if (_hProcess != NULL &&
2638 _OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2639 _LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2641 TOKEN_PRIVILEGES tp;
2642 tp.PrivilegeCount = 1;
2643 tp.Privileges[0].Luid = luid;
2644 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2646 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2647 // privilege. Check GetLastError() too. See MSDN document.
2648 if (_AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2649 (GetLastError() == ERROR_SUCCESS)) {
2650 return true;
2651 }
2652 }
2654 return false;
2655 }
2657 static void cleanup_after_large_page_init() {
2658 _GetLargePageMinimum = NULL;
2659 _AdjustTokenPrivileges = NULL;
2660 _OpenProcessToken = NULL;
2661 _LookupPrivilegeValue = NULL;
2662 if (_kernel32) FreeLibrary(_kernel32);
2663 _kernel32 = NULL;
2664 if (_advapi32) FreeLibrary(_advapi32);
2665 _advapi32 = NULL;
2666 if (_hProcess) CloseHandle(_hProcess);
2667 _hProcess = NULL;
2668 if (_hToken) CloseHandle(_hToken);
2669 _hToken = NULL;
2670 }
2672 bool os::large_page_init() {
2673 if (!UseLargePages) return false;
2675 // print a warning if any large page related flag is specified on command line
2676 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2677 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2678 bool success = false;
2680 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2681 if (resolve_functions_for_large_page_init()) {
2682 if (request_lock_memory_privilege()) {
2683 size_t s = _GetLargePageMinimum();
2684 if (s) {
2685 #if defined(IA32) || defined(AMD64)
2686 if (s > 4*M || LargePageSizeInBytes > 4*M) {
2687 WARN("JVM cannot use large pages bigger than 4mb.");
2688 } else {
2689 #endif
2690 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2691 _large_page_size = LargePageSizeInBytes;
2692 } else {
2693 _large_page_size = s;
2694 }
2695 success = true;
2696 #if defined(IA32) || defined(AMD64)
2697 }
2698 #endif
2699 } else {
2700 WARN("Large page is not supported by the processor.");
2701 }
2702 } else {
2703 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2704 }
2705 } else {
2706 WARN("Large page is not supported by the operating system.");
2707 }
2708 #undef WARN
2710 const size_t default_page_size = (size_t) vm_page_size();
2711 if (success && _large_page_size > default_page_size) {
2712 _page_sizes[0] = _large_page_size;
2713 _page_sizes[1] = default_page_size;
2714 _page_sizes[2] = 0;
2715 }
2717 cleanup_after_large_page_init();
2718 return success;
2719 }
2721 // On win32, one cannot release just a part of reserved memory, it's an
2722 // all or nothing deal. When we split a reservation, we must break the
2723 // reservation into two reservations.
2724 void os::split_reserved_memory(char *base, size_t size, size_t split,
2725 bool realloc) {
2726 if (size > 0) {
2727 release_memory(base, size);
2728 if (realloc) {
2729 reserve_memory(split, base);
2730 }
2731 if (size != split) {
2732 reserve_memory(size - split, base + split);
2733 }
2734 }
2735 }
2737 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2738 assert((size_t)addr % os::vm_allocation_granularity() == 0,
2739 "reserve alignment");
2740 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2741 char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2742 assert(res == NULL || addr == NULL || addr == res,
2743 "Unexpected address from reserve.");
2744 return res;
2745 }
2747 // Reserve memory at an arbitrary address, only if that area is
2748 // available (and not reserved for something else).
2749 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2750 // Windows os::reserve_memory() fails of the requested address range is
2751 // not avilable.
2752 return reserve_memory(bytes, requested_addr);
2753 }
2755 size_t os::large_page_size() {
2756 return _large_page_size;
2757 }
2759 bool os::can_commit_large_page_memory() {
2760 // Windows only uses large page memory when the entire region is reserved
2761 // and committed in a single VirtualAlloc() call. This may change in the
2762 // future, but with Windows 2003 it's not possible to commit on demand.
2763 return false;
2764 }
2766 bool os::can_execute_large_page_memory() {
2767 return true;
2768 }
2770 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2772 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
2774 if (UseLargePagesIndividualAllocation) {
2775 if (TracePageSizes && Verbose) {
2776 tty->print_cr("Reserving large pages individually.");
2777 }
2778 char * p_buf;
2779 // first reserve enough address space in advance since we want to be
2780 // able to break a single contiguous virtual address range into multiple
2781 // large page commits but WS2003 does not allow reserving large page space
2782 // so we just use 4K pages for reserve, this gives us a legal contiguous
2783 // address space. then we will deallocate that reservation, and re alloc
2784 // using large pages
2785 const size_t size_of_reserve = bytes + _large_page_size;
2786 if (bytes > size_of_reserve) {
2787 // Overflowed.
2788 warning("Individually allocated large pages failed, "
2789 "use -XX:-UseLargePagesIndividualAllocation to turn off");
2790 return NULL;
2791 }
2792 p_buf = (char *) VirtualAlloc(addr,
2793 size_of_reserve, // size of Reserve
2794 MEM_RESERVE,
2795 PAGE_READWRITE);
2796 // If reservation failed, return NULL
2797 if (p_buf == NULL) return NULL;
2799 release_memory(p_buf, bytes + _large_page_size);
2800 // round up to page boundary. If the size_of_reserve did not
2801 // overflow and the reservation did not fail, this align up
2802 // should not overflow.
2803 p_buf = (char *) align_size_up((size_t)p_buf, _large_page_size);
2805 // now go through and allocate one page at a time until all bytes are
2806 // allocated
2807 size_t bytes_remaining = align_size_up(bytes, _large_page_size);
2808 // An overflow of align_size_up() would have been caught above
2809 // in the calculation of size_of_reserve.
2810 char * next_alloc_addr = p_buf;
2812 #ifdef ASSERT
2813 // Variable for the failure injection
2814 long ran_num = os::random();
2815 size_t fail_after = ran_num % bytes;
2816 #endif
2818 while (bytes_remaining) {
2819 size_t bytes_to_rq = MIN2(bytes_remaining, _large_page_size);
2820 // Note allocate and commit
2821 char * p_new;
2823 #ifdef ASSERT
2824 bool inject_error = LargePagesIndividualAllocationInjectError &&
2825 (bytes_remaining <= fail_after);
2826 #else
2827 const bool inject_error = false;
2828 #endif
2830 if (inject_error) {
2831 p_new = NULL;
2832 } else {
2833 p_new = (char *) VirtualAlloc(next_alloc_addr,
2834 bytes_to_rq,
2835 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES,
2836 prot);
2837 }
2839 if (p_new == NULL) {
2840 // Free any allocated pages
2841 if (next_alloc_addr > p_buf) {
2842 // Some memory was committed so release it.
2843 size_t bytes_to_release = bytes - bytes_remaining;
2844 release_memory(p_buf, bytes_to_release);
2845 }
2846 #ifdef ASSERT
2847 if (UseLargePagesIndividualAllocation &&
2848 LargePagesIndividualAllocationInjectError) {
2849 if (TracePageSizes && Verbose) {
2850 tty->print_cr("Reserving large pages individually failed.");
2851 }
2852 }
2853 #endif
2854 return NULL;
2855 }
2856 bytes_remaining -= bytes_to_rq;
2857 next_alloc_addr += bytes_to_rq;
2858 }
2860 return p_buf;
2862 } else {
2863 // normal policy just allocate it all at once
2864 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2865 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
2866 return res;
2867 }
2868 }
2870 bool os::release_memory_special(char* base, size_t bytes) {
2871 return release_memory(base, bytes);
2872 }
2874 void os::print_statistics() {
2875 }
2877 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
2878 if (bytes == 0) {
2879 // Don't bother the OS with noops.
2880 return true;
2881 }
2882 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
2883 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
2884 // Don't attempt to print anything if the OS call fails. We're
2885 // probably low on resources, so the print itself may cause crashes.
2886 bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0;
2887 if (result != NULL && exec) {
2888 DWORD oldprot;
2889 // Windows doc says to use VirtualProtect to get execute permissions
2890 return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0;
2891 } else {
2892 return result;
2893 }
2894 }
2896 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
2897 bool exec) {
2898 return commit_memory(addr, size, exec);
2899 }
2901 bool os::uncommit_memory(char* addr, size_t bytes) {
2902 if (bytes == 0) {
2903 // Don't bother the OS with noops.
2904 return true;
2905 }
2906 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
2907 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
2908 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0;
2909 }
2911 bool os::release_memory(char* addr, size_t bytes) {
2912 return VirtualFree(addr, 0, MEM_RELEASE) != 0;
2913 }
2915 bool os::create_stack_guard_pages(char* addr, size_t size) {
2916 return os::commit_memory(addr, size);
2917 }
2919 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2920 return os::uncommit_memory(addr, size);
2921 }
2923 // Set protections specified
2924 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
2925 bool is_committed) {
2926 unsigned int p = 0;
2927 switch (prot) {
2928 case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
2929 case MEM_PROT_READ: p = PAGE_READONLY; break;
2930 case MEM_PROT_RW: p = PAGE_READWRITE; break;
2931 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break;
2932 default:
2933 ShouldNotReachHere();
2934 }
2936 DWORD old_status;
2938 // Strange enough, but on Win32 one can change protection only for committed
2939 // memory, not a big deal anyway, as bytes less or equal than 64K
2940 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
2941 fatal("cannot commit protection page");
2942 }
2943 // One cannot use os::guard_memory() here, as on Win32 guard page
2944 // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
2945 //
2946 // Pages in the region become guard pages. Any attempt to access a guard page
2947 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
2948 // the guard page status. Guard pages thus act as a one-time access alarm.
2949 return VirtualProtect(addr, bytes, p, &old_status) != 0;
2950 }
2952 bool os::guard_memory(char* addr, size_t bytes) {
2953 DWORD old_status;
2954 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
2955 }
2957 bool os::unguard_memory(char* addr, size_t bytes) {
2958 DWORD old_status;
2959 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
2960 }
2962 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
2963 void os::free_memory(char *addr, size_t bytes) { }
2964 void os::numa_make_global(char *addr, size_t bytes) { }
2965 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { }
2966 bool os::numa_topology_changed() { return false; }
2967 size_t os::numa_get_groups_num() { return 1; }
2968 int os::numa_get_group_id() { return 0; }
2969 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2970 if (size > 0) {
2971 ids[0] = 0;
2972 return 1;
2973 }
2974 return 0;
2975 }
2977 bool os::get_page_info(char *start, page_info* info) {
2978 return false;
2979 }
2981 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2982 return end;
2983 }
2985 char* os::non_memory_address_word() {
2986 // Must never look like an address returned by reserve_memory,
2987 // even in its subfields (as defined by the CPU immediate fields,
2988 // if the CPU splits constants across multiple instructions).
2989 return (char*)-1;
2990 }
2992 #define MAX_ERROR_COUNT 100
2993 #define SYS_THREAD_ERROR 0xffffffffUL
2995 void os::pd_start_thread(Thread* thread) {
2996 DWORD ret = ResumeThread(thread->osthread()->thread_handle());
2997 // Returns previous suspend state:
2998 // 0: Thread was not suspended
2999 // 1: Thread is running now
3000 // >1: Thread is still suspended.
3001 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3002 }
3004 class HighResolutionInterval {
3005 // The default timer resolution seems to be 10 milliseconds.
3006 // (Where is this written down?)
3007 // If someone wants to sleep for only a fraction of the default,
3008 // then we set the timer resolution down to 1 millisecond for
3009 // the duration of their interval.
3010 // We carefully set the resolution back, since otherwise we
3011 // seem to incur an overhead (3%?) that we don't need.
3012 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3013 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3014 // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3015 // timeBeginPeriod() if the relative error exceeded some threshold.
3016 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3017 // to decreased efficiency related to increased timer "tick" rates. We want to minimize
3018 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3019 // resolution timers running.
3020 private:
3021 jlong resolution;
3022 public:
3023 HighResolutionInterval(jlong ms) {
3024 resolution = ms % 10L;
3025 if (resolution != 0) {
3026 MMRESULT result = timeBeginPeriod(1L);
3027 }
3028 }
3029 ~HighResolutionInterval() {
3030 if (resolution != 0) {
3031 MMRESULT result = timeEndPeriod(1L);
3032 }
3033 resolution = 0L;
3034 }
3035 };
3037 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3038 jlong limit = (jlong) MAXDWORD;
3040 while(ms > limit) {
3041 int res;
3042 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3043 return res;
3044 ms -= limit;
3045 }
3047 assert(thread == Thread::current(), "thread consistency check");
3048 OSThread* osthread = thread->osthread();
3049 OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3050 int result;
3051 if (interruptable) {
3052 assert(thread->is_Java_thread(), "must be java thread");
3053 JavaThread *jt = (JavaThread *) thread;
3054 ThreadBlockInVM tbivm(jt);
3056 jt->set_suspend_equivalent();
3057 // cleared by handle_special_suspend_equivalent_condition() or
3058 // java_suspend_self() via check_and_wait_while_suspended()
3060 HANDLE events[1];
3061 events[0] = osthread->interrupt_event();
3062 HighResolutionInterval *phri=NULL;
3063 if(!ForceTimeHighResolution)
3064 phri = new HighResolutionInterval( ms );
3065 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3066 result = OS_TIMEOUT;
3067 } else {
3068 ResetEvent(osthread->interrupt_event());
3069 osthread->set_interrupted(false);
3070 result = OS_INTRPT;
3071 }
3072 delete phri; //if it is NULL, harmless
3074 // were we externally suspended while we were waiting?
3075 jt->check_and_wait_while_suspended();
3076 } else {
3077 assert(!thread->is_Java_thread(), "must not be java thread");
3078 Sleep((long) ms);
3079 result = OS_TIMEOUT;
3080 }
3081 return result;
3082 }
3084 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3085 void os::infinite_sleep() {
3086 while (true) { // sleep forever ...
3087 Sleep(100000); // ... 100 seconds at a time
3088 }
3089 }
3091 typedef BOOL (WINAPI * STTSignature)(void) ;
3093 os::YieldResult os::NakedYield() {
3094 // Use either SwitchToThread() or Sleep(0)
3095 // Consider passing back the return value from SwitchToThread().
3096 // We use GetProcAddress() as ancient Win9X versions of windows doen't support SwitchToThread.
3097 // In that case we revert to Sleep(0).
3098 static volatile STTSignature stt = (STTSignature) 1 ;
3100 if (stt == ((STTSignature) 1)) {
3101 stt = (STTSignature) ::GetProcAddress (LoadLibrary ("Kernel32.dll"), "SwitchToThread") ;
3102 // It's OK if threads race during initialization as the operation above is idempotent.
3103 }
3104 if (stt != NULL) {
3105 return (*stt)() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3106 } else {
3107 Sleep (0) ;
3108 }
3109 return os::YIELD_UNKNOWN ;
3110 }
3112 void os::yield() { os::NakedYield(); }
3114 void os::yield_all(int attempts) {
3115 // Yields to all threads, including threads with lower priorities
3116 Sleep(1);
3117 }
3119 // Win32 only gives you access to seven real priorities at a time,
3120 // so we compress Java's ten down to seven. It would be better
3121 // if we dynamically adjusted relative priorities.
3123 int os::java_to_os_priority[MaxPriority + 1] = {
3124 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3125 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3126 THREAD_PRIORITY_LOWEST, // 2
3127 THREAD_PRIORITY_BELOW_NORMAL, // 3
3128 THREAD_PRIORITY_BELOW_NORMAL, // 4
3129 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3130 THREAD_PRIORITY_NORMAL, // 6
3131 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3132 THREAD_PRIORITY_ABOVE_NORMAL, // 8
3133 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3134 THREAD_PRIORITY_HIGHEST // 10 MaxPriority
3135 };
3137 int prio_policy1[MaxPriority + 1] = {
3138 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3139 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3140 THREAD_PRIORITY_LOWEST, // 2
3141 THREAD_PRIORITY_BELOW_NORMAL, // 3
3142 THREAD_PRIORITY_BELOW_NORMAL, // 4
3143 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3144 THREAD_PRIORITY_ABOVE_NORMAL, // 6
3145 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3146 THREAD_PRIORITY_HIGHEST, // 8
3147 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3148 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority
3149 };
3151 static int prio_init() {
3152 // If ThreadPriorityPolicy is 1, switch tables
3153 if (ThreadPriorityPolicy == 1) {
3154 int i;
3155 for (i = 0; i < MaxPriority + 1; i++) {
3156 os::java_to_os_priority[i] = prio_policy1[i];
3157 }
3158 }
3159 return 0;
3160 }
3162 OSReturn os::set_native_priority(Thread* thread, int priority) {
3163 if (!UseThreadPriorities) return OS_OK;
3164 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3165 return ret ? OS_OK : OS_ERR;
3166 }
3168 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3169 if ( !UseThreadPriorities ) {
3170 *priority_ptr = java_to_os_priority[NormPriority];
3171 return OS_OK;
3172 }
3173 int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3174 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3175 assert(false, "GetThreadPriority failed");
3176 return OS_ERR;
3177 }
3178 *priority_ptr = os_prio;
3179 return OS_OK;
3180 }
3183 // Hint to the underlying OS that a task switch would not be good.
3184 // Void return because it's a hint and can fail.
3185 void os::hint_no_preempt() {}
3187 void os::interrupt(Thread* thread) {
3188 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3189 "possibility of dangling Thread pointer");
3191 OSThread* osthread = thread->osthread();
3192 osthread->set_interrupted(true);
3193 // More than one thread can get here with the same value of osthread,
3194 // resulting in multiple notifications. We do, however, want the store
3195 // to interrupted() to be visible to other threads before we post
3196 // the interrupt event.
3197 OrderAccess::release();
3198 SetEvent(osthread->interrupt_event());
3199 // For JSR166: unpark after setting status
3200 if (thread->is_Java_thread())
3201 ((JavaThread*)thread)->parker()->unpark();
3203 ParkEvent * ev = thread->_ParkEvent ;
3204 if (ev != NULL) ev->unpark() ;
3206 }
3209 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3210 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3211 "possibility of dangling Thread pointer");
3213 OSThread* osthread = thread->osthread();
3214 bool interrupted;
3215 interrupted = osthread->interrupted();
3216 if (clear_interrupted == true) {
3217 osthread->set_interrupted(false);
3218 ResetEvent(osthread->interrupt_event());
3219 } // Otherwise leave the interrupted state alone
3221 return interrupted;
3222 }
3224 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3225 ExtendedPC os::get_thread_pc(Thread* thread) {
3226 CONTEXT context;
3227 context.ContextFlags = CONTEXT_CONTROL;
3228 HANDLE handle = thread->osthread()->thread_handle();
3229 #ifdef _M_IA64
3230 assert(0, "Fix get_thread_pc");
3231 return ExtendedPC(NULL);
3232 #else
3233 if (GetThreadContext(handle, &context)) {
3234 #ifdef _M_AMD64
3235 return ExtendedPC((address) context.Rip);
3236 #else
3237 return ExtendedPC((address) context.Eip);
3238 #endif
3239 } else {
3240 return ExtendedPC(NULL);
3241 }
3242 #endif
3243 }
3245 // GetCurrentThreadId() returns DWORD
3246 intx os::current_thread_id() { return GetCurrentThreadId(); }
3248 static int _initial_pid = 0;
3250 int os::current_process_id()
3251 {
3252 return (_initial_pid ? _initial_pid : _getpid());
3253 }
3255 int os::win32::_vm_page_size = 0;
3256 int os::win32::_vm_allocation_granularity = 0;
3257 int os::win32::_processor_type = 0;
3258 // Processor level is not available on non-NT systems, use vm_version instead
3259 int os::win32::_processor_level = 0;
3260 julong os::win32::_physical_memory = 0;
3261 size_t os::win32::_default_stack_size = 0;
3263 intx os::win32::_os_thread_limit = 0;
3264 volatile intx os::win32::_os_thread_count = 0;
3266 bool os::win32::_is_nt = false;
3267 bool os::win32::_is_windows_2003 = false;
3270 void os::win32::initialize_system_info() {
3271 SYSTEM_INFO si;
3272 GetSystemInfo(&si);
3273 _vm_page_size = si.dwPageSize;
3274 _vm_allocation_granularity = si.dwAllocationGranularity;
3275 _processor_type = si.dwProcessorType;
3276 _processor_level = si.wProcessorLevel;
3277 set_processor_count(si.dwNumberOfProcessors);
3279 MEMORYSTATUSEX ms;
3280 ms.dwLength = sizeof(ms);
3282 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3283 // dwMemoryLoad (% of memory in use)
3284 GlobalMemoryStatusEx(&ms);
3285 _physical_memory = ms.ullTotalPhys;
3287 OSVERSIONINFO oi;
3288 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
3289 GetVersionEx(&oi);
3290 switch(oi.dwPlatformId) {
3291 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3292 case VER_PLATFORM_WIN32_NT:
3293 _is_nt = true;
3294 {
3295 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3296 if (os_vers == 5002) {
3297 _is_windows_2003 = true;
3298 }
3299 }
3300 break;
3301 default: fatal("Unknown platform");
3302 }
3304 _default_stack_size = os::current_stack_size();
3305 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3306 assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3307 "stack size not a multiple of page size");
3309 initialize_performance_counter();
3311 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3312 // known to deadlock the system, if the VM issues to thread operations with
3313 // a too high frequency, e.g., such as changing the priorities.
3314 // The 6000 seems to work well - no deadlocks has been notices on the test
3315 // programs that we have seen experience this problem.
3316 if (!os::win32::is_nt()) {
3317 StarvationMonitorInterval = 6000;
3318 }
3319 }
3322 void os::win32::setmode_streams() {
3323 _setmode(_fileno(stdin), _O_BINARY);
3324 _setmode(_fileno(stdout), _O_BINARY);
3325 _setmode(_fileno(stderr), _O_BINARY);
3326 }
3329 int os::message_box(const char* title, const char* message) {
3330 int result = MessageBox(NULL, message, title,
3331 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3332 return result == IDYES;
3333 }
3335 int os::allocate_thread_local_storage() {
3336 return TlsAlloc();
3337 }
3340 void os::free_thread_local_storage(int index) {
3341 TlsFree(index);
3342 }
3345 void os::thread_local_storage_at_put(int index, void* value) {
3346 TlsSetValue(index, value);
3347 assert(thread_local_storage_at(index) == value, "Just checking");
3348 }
3351 void* os::thread_local_storage_at(int index) {
3352 return TlsGetValue(index);
3353 }
3356 #ifndef PRODUCT
3357 #ifndef _WIN64
3358 // Helpers to check whether NX protection is enabled
3359 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3360 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3361 pex->ExceptionRecord->NumberParameters > 0 &&
3362 pex->ExceptionRecord->ExceptionInformation[0] ==
3363 EXCEPTION_INFO_EXEC_VIOLATION) {
3364 return EXCEPTION_EXECUTE_HANDLER;
3365 }
3366 return EXCEPTION_CONTINUE_SEARCH;
3367 }
3369 void nx_check_protection() {
3370 // If NX is enabled we'll get an exception calling into code on the stack
3371 char code[] = { (char)0xC3 }; // ret
3372 void *code_ptr = (void *)code;
3373 __try {
3374 __asm call code_ptr
3375 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3376 tty->print_raw_cr("NX protection detected.");
3377 }
3378 }
3379 #endif // _WIN64
3380 #endif // PRODUCT
3382 // this is called _before_ the global arguments have been parsed
3383 void os::init(void) {
3384 _initial_pid = _getpid();
3386 init_random(1234567);
3388 win32::initialize_system_info();
3389 win32::setmode_streams();
3390 init_page_sizes((size_t) win32::vm_page_size());
3392 // For better scalability on MP systems (must be called after initialize_system_info)
3393 #ifndef PRODUCT
3394 if (is_MP()) {
3395 NoYieldsInMicrolock = true;
3396 }
3397 #endif
3398 // This may be overridden later when argument processing is done.
3399 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3400 os::win32::is_windows_2003());
3402 // Initialize main_process and main_thread
3403 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle
3404 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3405 &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3406 fatal("DuplicateHandle failed\n");
3407 }
3408 main_thread_id = (int) GetCurrentThreadId();
3409 }
3411 // To install functions for atexit processing
3412 extern "C" {
3413 static void perfMemory_exit_helper() {
3414 perfMemory_exit();
3415 }
3416 }
3418 // this is called _after_ the global arguments have been parsed
3419 jint os::init_2(void) {
3420 // Allocate a single page and mark it as readable for safepoint polling
3421 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3422 guarantee( polling_page != NULL, "Reserve Failed for polling page");
3424 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3425 guarantee( return_page != NULL, "Commit Failed for polling page");
3427 os::set_polling_page( polling_page );
3429 #ifndef PRODUCT
3430 if( Verbose && PrintMiscellaneous )
3431 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3432 #endif
3434 if (!UseMembar) {
3435 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3436 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3438 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3439 guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3441 os::set_memory_serialize_page( mem_serialize_page );
3443 #ifndef PRODUCT
3444 if(Verbose && PrintMiscellaneous)
3445 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3446 #endif
3447 }
3449 FLAG_SET_DEFAULT(UseLargePages, os::large_page_init());
3451 // Setup Windows Exceptions
3453 // On Itanium systems, Structured Exception Handling does not
3454 // work since stack frames must be walkable by the OS. Since
3455 // much of our code is dynamically generated, and we do not have
3456 // proper unwind .xdata sections, the system simply exits
3457 // rather than delivering the exception. To work around
3458 // this we use VectorExceptions instead.
3459 #ifdef _WIN64
3460 if (UseVectoredExceptions) {
3461 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3462 }
3463 #endif
3465 // for debugging float code generation bugs
3466 if (ForceFloatExceptions) {
3467 #ifndef _WIN64
3468 static long fp_control_word = 0;
3469 __asm { fstcw fp_control_word }
3470 // see Intel PPro Manual, Vol. 2, p 7-16
3471 const long precision = 0x20;
3472 const long underflow = 0x10;
3473 const long overflow = 0x08;
3474 const long zero_div = 0x04;
3475 const long denorm = 0x02;
3476 const long invalid = 0x01;
3477 fp_control_word |= invalid;
3478 __asm { fldcw fp_control_word }
3479 #endif
3480 }
3482 // If stack_commit_size is 0, windows will reserve the default size,
3483 // but only commit a small portion of it.
3484 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3485 size_t default_reserve_size = os::win32::default_stack_size();
3486 size_t actual_reserve_size = stack_commit_size;
3487 if (stack_commit_size < default_reserve_size) {
3488 // If stack_commit_size == 0, we want this too
3489 actual_reserve_size = default_reserve_size;
3490 }
3492 // Check minimum allowable stack size for thread creation and to initialize
3493 // the java system classes, including StackOverflowError - depends on page
3494 // size. Add a page for compiler2 recursion in main thread.
3495 // Add in 2*BytesPerWord times page size to account for VM stack during
3496 // class initialization depending on 32 or 64 bit VM.
3497 size_t min_stack_allowed =
3498 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3499 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3500 if (actual_reserve_size < min_stack_allowed) {
3501 tty->print_cr("\nThe stack size specified is too small, "
3502 "Specify at least %dk",
3503 min_stack_allowed / K);
3504 return JNI_ERR;
3505 }
3507 JavaThread::set_stack_size_at_create(stack_commit_size);
3509 // Calculate theoretical max. size of Threads to guard gainst artifical
3510 // out-of-memory situations, where all available address-space has been
3511 // reserved by thread stacks.
3512 assert(actual_reserve_size != 0, "Must have a stack");
3514 // Calculate the thread limit when we should start doing Virtual Memory
3515 // banging. Currently when the threads will have used all but 200Mb of space.
3516 //
3517 // TODO: consider performing a similar calculation for commit size instead
3518 // as reserve size, since on a 64-bit platform we'll run into that more
3519 // often than running out of virtual memory space. We can use the
3520 // lower value of the two calculations as the os_thread_limit.
3521 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3522 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3524 // at exit methods are called in the reverse order of their registration.
3525 // there is no limit to the number of functions registered. atexit does
3526 // not set errno.
3528 if (PerfAllowAtExitRegistration) {
3529 // only register atexit functions if PerfAllowAtExitRegistration is set.
3530 // atexit functions can be delayed until process exit time, which
3531 // can be problematic for embedded VM situations. Embedded VMs should
3532 // call DestroyJavaVM() to assure that VM resources are released.
3534 // note: perfMemory_exit_helper atexit function may be removed in
3535 // the future if the appropriate cleanup code can be added to the
3536 // VM_Exit VMOperation's doit method.
3537 if (atexit(perfMemory_exit_helper) != 0) {
3538 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3539 }
3540 }
3542 // initialize PSAPI or ToolHelp for fatal error handler
3543 if (win32::is_nt()) _init_psapi();
3544 else _init_toolhelp();
3546 #ifndef _WIN64
3547 // Print something if NX is enabled (win32 on AMD64)
3548 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3549 #endif
3551 // initialize thread priority policy
3552 prio_init();
3554 if (UseNUMA && !ForceNUMA) {
3555 UseNUMA = false; // Currently unsupported.
3556 }
3558 return JNI_OK;
3559 }
3561 void os::init_3(void) {
3562 return;
3563 }
3565 // Mark the polling page as unreadable
3566 void os::make_polling_page_unreadable(void) {
3567 DWORD old_status;
3568 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3569 fatal("Could not disable polling page");
3570 };
3572 // Mark the polling page as readable
3573 void os::make_polling_page_readable(void) {
3574 DWORD old_status;
3575 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3576 fatal("Could not enable polling page");
3577 };
3580 int os::stat(const char *path, struct stat *sbuf) {
3581 char pathbuf[MAX_PATH];
3582 if (strlen(path) > MAX_PATH - 1) {
3583 errno = ENAMETOOLONG;
3584 return -1;
3585 }
3586 os::native_path(strcpy(pathbuf, path));
3587 int ret = ::stat(pathbuf, sbuf);
3588 if (sbuf != NULL && UseUTCFileTimestamp) {
3589 // Fix for 6539723. st_mtime returned from stat() is dependent on
3590 // the system timezone and so can return different values for the
3591 // same file if/when daylight savings time changes. This adjustment
3592 // makes sure the same timestamp is returned regardless of the TZ.
3593 //
3594 // See:
3595 // http://msdn.microsoft.com/library/
3596 // default.asp?url=/library/en-us/sysinfo/base/
3597 // time_zone_information_str.asp
3598 // and
3599 // http://msdn.microsoft.com/library/default.asp?url=
3600 // /library/en-us/sysinfo/base/settimezoneinformation.asp
3601 //
3602 // NOTE: there is a insidious bug here: If the timezone is changed
3603 // after the call to stat() but before 'GetTimeZoneInformation()', then
3604 // the adjustment we do here will be wrong and we'll return the wrong
3605 // value (which will likely end up creating an invalid class data
3606 // archive). Absent a better API for this, or some time zone locking
3607 // mechanism, we'll have to live with this risk.
3608 TIME_ZONE_INFORMATION tz;
3609 DWORD tzid = GetTimeZoneInformation(&tz);
3610 int daylightBias =
3611 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias;
3612 sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3613 }
3614 return ret;
3615 }
3618 #define FT2INT64(ft) \
3619 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3622 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3623 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3624 // of a thread.
3625 //
3626 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3627 // the fast estimate available on the platform.
3629 // current_thread_cpu_time() is not optimized for Windows yet
3630 jlong os::current_thread_cpu_time() {
3631 // return user + sys since the cost is the same
3632 return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3633 }
3635 jlong os::thread_cpu_time(Thread* thread) {
3636 // consistent with what current_thread_cpu_time() returns.
3637 return os::thread_cpu_time(thread, true /* user+sys */);
3638 }
3640 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3641 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3642 }
3644 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3645 // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3646 // If this function changes, os::is_thread_cpu_time_supported() should too
3647 if (os::win32::is_nt()) {
3648 FILETIME CreationTime;
3649 FILETIME ExitTime;
3650 FILETIME KernelTime;
3651 FILETIME UserTime;
3653 if ( GetThreadTimes(thread->osthread()->thread_handle(),
3654 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3655 return -1;
3656 else
3657 if (user_sys_cpu_time) {
3658 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3659 } else {
3660 return FT2INT64(UserTime) * 100;
3661 }
3662 } else {
3663 return (jlong) timeGetTime() * 1000000;
3664 }
3665 }
3667 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3668 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3669 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3670 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3671 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3672 }
3674 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3675 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3676 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3677 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3678 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3679 }
3681 bool os::is_thread_cpu_time_supported() {
3682 // see os::thread_cpu_time
3683 if (os::win32::is_nt()) {
3684 FILETIME CreationTime;
3685 FILETIME ExitTime;
3686 FILETIME KernelTime;
3687 FILETIME UserTime;
3689 if ( GetThreadTimes(GetCurrentThread(),
3690 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3691 return false;
3692 else
3693 return true;
3694 } else {
3695 return false;
3696 }
3697 }
3699 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3700 // It does have primitives (PDH API) to get CPU usage and run queue length.
3701 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3702 // If we wanted to implement loadavg on Windows, we have a few options:
3703 //
3704 // a) Query CPU usage and run queue length and "fake" an answer by
3705 // returning the CPU usage if it's under 100%, and the run queue
3706 // length otherwise. It turns out that querying is pretty slow
3707 // on Windows, on the order of 200 microseconds on a fast machine.
3708 // Note that on the Windows the CPU usage value is the % usage
3709 // since the last time the API was called (and the first call
3710 // returns 100%), so we'd have to deal with that as well.
3711 //
3712 // b) Sample the "fake" answer using a sampling thread and store
3713 // the answer in a global variable. The call to loadavg would
3714 // just return the value of the global, avoiding the slow query.
3715 //
3716 // c) Sample a better answer using exponential decay to smooth the
3717 // value. This is basically the algorithm used by UNIX kernels.
3718 //
3719 // Note that sampling thread starvation could affect both (b) and (c).
3720 int os::loadavg(double loadavg[], int nelem) {
3721 return -1;
3722 }
3725 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3726 bool os::dont_yield() {
3727 return DontYieldALot;
3728 }
3730 // This method is a slightly reworked copy of JDK's sysOpen
3731 // from src/windows/hpi/src/sys_api_md.c
3733 int os::open(const char *path, int oflag, int mode) {
3734 char pathbuf[MAX_PATH];
3736 if (strlen(path) > MAX_PATH - 1) {
3737 errno = ENAMETOOLONG;
3738 return -1;
3739 }
3740 os::native_path(strcpy(pathbuf, path));
3741 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
3742 }
3744 // Is a (classpath) directory empty?
3745 bool os::dir_is_empty(const char* path) {
3746 WIN32_FIND_DATA fd;
3747 HANDLE f = FindFirstFile(path, &fd);
3748 if (f == INVALID_HANDLE_VALUE) {
3749 return true;
3750 }
3751 FindClose(f);
3752 return false;
3753 }
3755 // create binary file, rewriting existing file if required
3756 int os::create_binary_file(const char* path, bool rewrite_existing) {
3757 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
3758 if (!rewrite_existing) {
3759 oflags |= _O_EXCL;
3760 }
3761 return ::open(path, oflags, _S_IREAD | _S_IWRITE);
3762 }
3764 // return current position of file pointer
3765 jlong os::current_file_offset(int fd) {
3766 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
3767 }
3769 // move file pointer to the specified offset
3770 jlong os::seek_to_file_offset(int fd, jlong offset) {
3771 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
3772 }
3775 jlong os::lseek(int fd, jlong offset, int whence) {
3776 return (jlong) ::_lseeki64(fd, offset, whence);
3777 }
3779 // This method is a slightly reworked copy of JDK's sysNativePath
3780 // from src/windows/hpi/src/path_md.c
3782 /* Convert a pathname to native format. On win32, this involves forcing all
3783 separators to be '\\' rather than '/' (both are legal inputs, but Win95
3784 sometimes rejects '/') and removing redundant separators. The input path is
3785 assumed to have been converted into the character encoding used by the local
3786 system. Because this might be a double-byte encoding, care is taken to
3787 treat double-byte lead characters correctly.
3789 This procedure modifies the given path in place, as the result is never
3790 longer than the original. There is no error return; this operation always
3791 succeeds. */
3792 char * os::native_path(char *path) {
3793 char *src = path, *dst = path, *end = path;
3794 char *colon = NULL; /* If a drive specifier is found, this will
3795 point to the colon following the drive
3796 letter */
3798 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
3799 assert(((!::IsDBCSLeadByte('/'))
3800 && (!::IsDBCSLeadByte('\\'))
3801 && (!::IsDBCSLeadByte(':'))),
3802 "Illegal lead byte");
3804 /* Check for leading separators */
3805 #define isfilesep(c) ((c) == '/' || (c) == '\\')
3806 while (isfilesep(*src)) {
3807 src++;
3808 }
3810 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
3811 /* Remove leading separators if followed by drive specifier. This
3812 hack is necessary to support file URLs containing drive
3813 specifiers (e.g., "file://c:/path"). As a side effect,
3814 "/c:/path" can be used as an alternative to "c:/path". */
3815 *dst++ = *src++;
3816 colon = dst;
3817 *dst++ = ':';
3818 src++;
3819 } else {
3820 src = path;
3821 if (isfilesep(src[0]) && isfilesep(src[1])) {
3822 /* UNC pathname: Retain first separator; leave src pointed at
3823 second separator so that further separators will be collapsed
3824 into the second separator. The result will be a pathname
3825 beginning with "\\\\" followed (most likely) by a host name. */
3826 src = dst = path + 1;
3827 path[0] = '\\'; /* Force first separator to '\\' */
3828 }
3829 }
3831 end = dst;
3833 /* Remove redundant separators from remainder of path, forcing all
3834 separators to be '\\' rather than '/'. Also, single byte space
3835 characters are removed from the end of the path because those
3836 are not legal ending characters on this operating system.
3837 */
3838 while (*src != '\0') {
3839 if (isfilesep(*src)) {
3840 *dst++ = '\\'; src++;
3841 while (isfilesep(*src)) src++;
3842 if (*src == '\0') {
3843 /* Check for trailing separator */
3844 end = dst;
3845 if (colon == dst - 2) break; /* "z:\\" */
3846 if (dst == path + 1) break; /* "\\" */
3847 if (dst == path + 2 && isfilesep(path[0])) {
3848 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
3849 beginning of a UNC pathname. Even though it is not, by
3850 itself, a valid UNC pathname, we leave it as is in order
3851 to be consistent with the path canonicalizer as well
3852 as the win32 APIs, which treat this case as an invalid
3853 UNC pathname rather than as an alias for the root
3854 directory of the current drive. */
3855 break;
3856 }
3857 end = --dst; /* Path does not denote a root directory, so
3858 remove trailing separator */
3859 break;
3860 }
3861 end = dst;
3862 } else {
3863 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
3864 *dst++ = *src++;
3865 if (*src) *dst++ = *src++;
3866 end = dst;
3867 } else { /* Copy a single-byte character */
3868 char c = *src++;
3869 *dst++ = c;
3870 /* Space is not a legal ending character */
3871 if (c != ' ') end = dst;
3872 }
3873 }
3874 }
3876 *end = '\0';
3878 /* For "z:", add "." to work around a bug in the C runtime library */
3879 if (colon == dst - 1) {
3880 path[2] = '.';
3881 path[3] = '\0';
3882 }
3884 #ifdef DEBUG
3885 jio_fprintf(stderr, "sysNativePath: %s\n", path);
3886 #endif DEBUG
3887 return path;
3888 }
3890 // This code is a copy of JDK's sysSetLength
3891 // from src/windows/hpi/src/sys_api_md.c
3893 int os::ftruncate(int fd, jlong length) {
3894 HANDLE h = (HANDLE)::_get_osfhandle(fd);
3895 long high = (long)(length >> 32);
3896 DWORD ret;
3898 if (h == (HANDLE)(-1)) {
3899 return -1;
3900 }
3902 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
3903 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
3904 return -1;
3905 }
3907 if (::SetEndOfFile(h) == FALSE) {
3908 return -1;
3909 }
3911 return 0;
3912 }
3915 // This code is a copy of JDK's sysSync
3916 // from src/windows/hpi/src/sys_api_md.c
3917 // except for the legacy workaround for a bug in Win 98
3919 int os::fsync(int fd) {
3920 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
3922 if ( (!::FlushFileBuffers(handle)) &&
3923 (GetLastError() != ERROR_ACCESS_DENIED) ) {
3924 /* from winerror.h */
3925 return -1;
3926 }
3927 return 0;
3928 }
3930 static int nonSeekAvailable(int, long *);
3931 static int stdinAvailable(int, long *);
3933 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR)
3934 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO)
3936 // This code is a copy of JDK's sysAvailable
3937 // from src/windows/hpi/src/sys_api_md.c
3939 int os::available(int fd, jlong *bytes) {
3940 jlong cur, end;
3941 struct _stati64 stbuf64;
3943 if (::_fstati64(fd, &stbuf64) >= 0) {
3944 int mode = stbuf64.st_mode;
3945 if (S_ISCHR(mode) || S_ISFIFO(mode)) {
3946 int ret;
3947 long lpbytes;
3948 if (fd == 0) {
3949 ret = stdinAvailable(fd, &lpbytes);
3950 } else {
3951 ret = nonSeekAvailable(fd, &lpbytes);
3952 }
3953 (*bytes) = (jlong)(lpbytes);
3954 return ret;
3955 }
3956 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
3957 return FALSE;
3958 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
3959 return FALSE;
3960 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
3961 return FALSE;
3962 }
3963 *bytes = end - cur;
3964 return TRUE;
3965 } else {
3966 return FALSE;
3967 }
3968 }
3970 // This code is a copy of JDK's nonSeekAvailable
3971 // from src/windows/hpi/src/sys_api_md.c
3973 static int nonSeekAvailable(int fd, long *pbytes) {
3974 /* This is used for available on non-seekable devices
3975 * (like both named and anonymous pipes, such as pipes
3976 * connected to an exec'd process).
3977 * Standard Input is a special case.
3978 *
3979 */
3980 HANDLE han;
3982 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
3983 return FALSE;
3984 }
3986 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
3987 /* PeekNamedPipe fails when at EOF. In that case we
3988 * simply make *pbytes = 0 which is consistent with the
3989 * behavior we get on Solaris when an fd is at EOF.
3990 * The only alternative is to raise an Exception,
3991 * which isn't really warranted.
3992 */
3993 if (::GetLastError() != ERROR_BROKEN_PIPE) {
3994 return FALSE;
3995 }
3996 *pbytes = 0;
3997 }
3998 return TRUE;
3999 }
4001 #define MAX_INPUT_EVENTS 2000
4003 // This code is a copy of JDK's stdinAvailable
4004 // from src/windows/hpi/src/sys_api_md.c
4006 static int stdinAvailable(int fd, long *pbytes) {
4007 HANDLE han;
4008 DWORD numEventsRead = 0; /* Number of events read from buffer */
4009 DWORD numEvents = 0; /* Number of events in buffer */
4010 DWORD i = 0; /* Loop index */
4011 DWORD curLength = 0; /* Position marker */
4012 DWORD actualLength = 0; /* Number of bytes readable */
4013 BOOL error = FALSE; /* Error holder */
4014 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */
4016 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4017 return FALSE;
4018 }
4020 /* Construct an array of input records in the console buffer */
4021 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4022 if (error == 0) {
4023 return nonSeekAvailable(fd, pbytes);
4024 }
4026 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4027 if (numEvents > MAX_INPUT_EVENTS) {
4028 numEvents = MAX_INPUT_EVENTS;
4029 }
4031 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD));
4032 if (lpBuffer == NULL) {
4033 return FALSE;
4034 }
4036 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4037 if (error == 0) {
4038 os::free(lpBuffer);
4039 return FALSE;
4040 }
4042 /* Examine input records for the number of bytes available */
4043 for(i=0; i<numEvents; i++) {
4044 if (lpBuffer[i].EventType == KEY_EVENT) {
4046 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4047 &(lpBuffer[i].Event);
4048 if (keyRecord->bKeyDown == TRUE) {
4049 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4050 curLength++;
4051 if (*keyPressed == '\r') {
4052 actualLength = curLength;
4053 }
4054 }
4055 }
4056 }
4058 if(lpBuffer != NULL) {
4059 os::free(lpBuffer);
4060 }
4062 *pbytes = (long) actualLength;
4063 return TRUE;
4064 }
4066 // Map a block of memory.
4067 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
4068 char *addr, size_t bytes, bool read_only,
4069 bool allow_exec) {
4070 HANDLE hFile;
4071 char* base;
4073 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4074 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4075 if (hFile == NULL) {
4076 if (PrintMiscellaneous && Verbose) {
4077 DWORD err = GetLastError();
4078 tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4079 }
4080 return NULL;
4081 }
4083 if (allow_exec) {
4084 // CreateFileMapping/MapViewOfFileEx can't map executable memory
4085 // unless it comes from a PE image (which the shared archive is not.)
4086 // Even VirtualProtect refuses to give execute access to mapped memory
4087 // that was not previously executable.
4088 //
4089 // Instead, stick the executable region in anonymous memory. Yuck.
4090 // Penalty is that ~4 pages will not be shareable - in the future
4091 // we might consider DLLizing the shared archive with a proper PE
4092 // header so that mapping executable + sharing is possible.
4094 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4095 PAGE_READWRITE);
4096 if (base == NULL) {
4097 if (PrintMiscellaneous && Verbose) {
4098 DWORD err = GetLastError();
4099 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4100 }
4101 CloseHandle(hFile);
4102 return NULL;
4103 }
4105 DWORD bytes_read;
4106 OVERLAPPED overlapped;
4107 overlapped.Offset = (DWORD)file_offset;
4108 overlapped.OffsetHigh = 0;
4109 overlapped.hEvent = NULL;
4110 // ReadFile guarantees that if the return value is true, the requested
4111 // number of bytes were read before returning.
4112 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4113 if (!res) {
4114 if (PrintMiscellaneous && Verbose) {
4115 DWORD err = GetLastError();
4116 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4117 }
4118 release_memory(base, bytes);
4119 CloseHandle(hFile);
4120 return NULL;
4121 }
4122 } else {
4123 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4124 NULL /*file_name*/);
4125 if (hMap == NULL) {
4126 if (PrintMiscellaneous && Verbose) {
4127 DWORD err = GetLastError();
4128 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4129 }
4130 CloseHandle(hFile);
4131 return NULL;
4132 }
4134 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4135 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4136 (DWORD)bytes, addr);
4137 if (base == NULL) {
4138 if (PrintMiscellaneous && Verbose) {
4139 DWORD err = GetLastError();
4140 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4141 }
4142 CloseHandle(hMap);
4143 CloseHandle(hFile);
4144 return NULL;
4145 }
4147 if (CloseHandle(hMap) == 0) {
4148 if (PrintMiscellaneous && Verbose) {
4149 DWORD err = GetLastError();
4150 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4151 }
4152 CloseHandle(hFile);
4153 return base;
4154 }
4155 }
4157 if (allow_exec) {
4158 DWORD old_protect;
4159 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4160 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4162 if (!res) {
4163 if (PrintMiscellaneous && Verbose) {
4164 DWORD err = GetLastError();
4165 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4166 }
4167 // Don't consider this a hard error, on IA32 even if the
4168 // VirtualProtect fails, we should still be able to execute
4169 CloseHandle(hFile);
4170 return base;
4171 }
4172 }
4174 if (CloseHandle(hFile) == 0) {
4175 if (PrintMiscellaneous && Verbose) {
4176 DWORD err = GetLastError();
4177 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4178 }
4179 return base;
4180 }
4182 return base;
4183 }
4186 // Remap a block of memory.
4187 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
4188 char *addr, size_t bytes, bool read_only,
4189 bool allow_exec) {
4190 // This OS does not allow existing memory maps to be remapped so we
4191 // have to unmap the memory before we remap it.
4192 if (!os::unmap_memory(addr, bytes)) {
4193 return NULL;
4194 }
4196 // There is a very small theoretical window between the unmap_memory()
4197 // call above and the map_memory() call below where a thread in native
4198 // code may be able to access an address that is no longer mapped.
4200 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4201 allow_exec);
4202 }
4205 // Unmap a block of memory.
4206 // Returns true=success, otherwise false.
4208 bool os::unmap_memory(char* addr, size_t bytes) {
4209 BOOL result = UnmapViewOfFile(addr);
4210 if (result == 0) {
4211 if (PrintMiscellaneous && Verbose) {
4212 DWORD err = GetLastError();
4213 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4214 }
4215 return false;
4216 }
4217 return true;
4218 }
4220 void os::pause() {
4221 char filename[MAX_PATH];
4222 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4223 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4224 } else {
4225 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4226 }
4228 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4229 if (fd != -1) {
4230 struct stat buf;
4231 ::close(fd);
4232 while (::stat(filename, &buf) == 0) {
4233 Sleep(100);
4234 }
4235 } else {
4236 jio_fprintf(stderr,
4237 "Could not open pause file '%s', continuing immediately.\n", filename);
4238 }
4239 }
4241 // An Event wraps a win32 "CreateEvent" kernel handle.
4242 //
4243 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4244 //
4245 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4246 // field, and call CloseHandle() on the win32 event handle. Unpark() would
4247 // need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4248 // In addition, an unpark() operation might fetch the handle field, but the
4249 // event could recycle between the fetch and the SetEvent() operation.
4250 // SetEvent() would either fail because the handle was invalid, or inadvertently work,
4251 // as the win32 handle value had been recycled. In an ideal world calling SetEvent()
4252 // on an stale but recycled handle would be harmless, but in practice this might
4253 // confuse other non-Sun code, so it's not a viable approach.
4254 //
4255 // 2: Once a win32 event handle is associated with an Event, it remains associated
4256 // with the Event. The event handle is never closed. This could be construed
4257 // as handle leakage, but only up to the maximum # of threads that have been extant
4258 // at any one time. This shouldn't be an issue, as windows platforms typically
4259 // permit a process to have hundreds of thousands of open handles.
4260 //
4261 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4262 // and release unused handles.
4263 //
4264 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4265 // It's not clear, however, that we wouldn't be trading one type of leak for another.
4266 //
4267 // 5. Use an RCU-like mechanism (Read-Copy Update).
4268 // Or perhaps something similar to Maged Michael's "Hazard pointers".
4269 //
4270 // We use (2).
4271 //
4272 // TODO-FIXME:
4273 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4274 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4275 // to recover from (or at least detect) the dreaded Windows 841176 bug.
4276 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4277 // into a single win32 CreateEvent() handle.
4278 //
4279 // _Event transitions in park()
4280 // -1 => -1 : illegal
4281 // 1 => 0 : pass - return immediately
4282 // 0 => -1 : block
4283 //
4284 // _Event serves as a restricted-range semaphore :
4285 // -1 : thread is blocked
4286 // 0 : neutral - thread is running or ready
4287 // 1 : signaled - thread is running or ready
4288 //
4289 // Another possible encoding of _Event would be
4290 // with explicit "PARKED" and "SIGNALED" bits.
4292 int os::PlatformEvent::park (jlong Millis) {
4293 guarantee (_ParkHandle != NULL , "Invariant") ;
4294 guarantee (Millis > 0 , "Invariant") ;
4295 int v ;
4297 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4298 // the initial park() operation.
4300 for (;;) {
4301 v = _Event ;
4302 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4303 }
4304 guarantee ((v == 0) || (v == 1), "invariant") ;
4305 if (v != 0) return OS_OK ;
4307 // Do this the hard way by blocking ...
4308 // TODO: consider a brief spin here, gated on the success of recent
4309 // spin attempts by this thread.
4310 //
4311 // We decompose long timeouts into series of shorter timed waits.
4312 // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4313 // versions of Windows. See EventWait() for details. This may be superstition. Or not.
4314 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4315 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from
4316 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4317 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv ==
4318 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4319 // for the already waited time. This policy does not admit any new outcomes.
4320 // In the future, however, we might want to track the accumulated wait time and
4321 // adjust Millis accordingly if we encounter a spurious wakeup.
4323 const int MAXTIMEOUT = 0x10000000 ;
4324 DWORD rv = WAIT_TIMEOUT ;
4325 while (_Event < 0 && Millis > 0) {
4326 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT)
4327 if (Millis > MAXTIMEOUT) {
4328 prd = MAXTIMEOUT ;
4329 }
4330 rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4331 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4332 if (rv == WAIT_TIMEOUT) {
4333 Millis -= prd ;
4334 }
4335 }
4336 v = _Event ;
4337 _Event = 0 ;
4338 OrderAccess::fence() ;
4339 // If we encounter a nearly simultanous timeout expiry and unpark()
4340 // we return OS_OK indicating we awoke via unpark().
4341 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4342 return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4343 }
4345 void os::PlatformEvent::park () {
4346 guarantee (_ParkHandle != NULL, "Invariant") ;
4347 // Invariant: Only the thread associated with the Event/PlatformEvent
4348 // may call park().
4349 int v ;
4350 for (;;) {
4351 v = _Event ;
4352 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4353 }
4354 guarantee ((v == 0) || (v == 1), "invariant") ;
4355 if (v != 0) return ;
4357 // Do this the hard way by blocking ...
4358 // TODO: consider a brief spin here, gated on the success of recent
4359 // spin attempts by this thread.
4360 while (_Event < 0) {
4361 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4362 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4363 }
4365 // Usually we'll find _Event == 0 at this point, but as
4366 // an optional optimization we clear it, just in case can
4367 // multiple unpark() operations drove _Event up to 1.
4368 _Event = 0 ;
4369 OrderAccess::fence() ;
4370 guarantee (_Event >= 0, "invariant") ;
4371 }
4373 void os::PlatformEvent::unpark() {
4374 guarantee (_ParkHandle != NULL, "Invariant") ;
4375 int v ;
4376 for (;;) {
4377 v = _Event ; // Increment _Event if it's < 1.
4378 if (v > 0) {
4379 // If it's already signaled just return.
4380 // The LD of _Event could have reordered or be satisfied
4381 // by a read-aside from this processor's write buffer.
4382 // To avoid problems execute a barrier and then
4383 // ratify the value. A degenerate CAS() would also work.
4384 // Viz., CAS (v+0, &_Event, v) == v).
4385 OrderAccess::fence() ;
4386 if (_Event == v) return ;
4387 continue ;
4388 }
4389 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4390 }
4391 if (v < 0) {
4392 ::SetEvent (_ParkHandle) ;
4393 }
4394 }
4397 // JSR166
4398 // -------------------------------------------------------
4400 /*
4401 * The Windows implementation of Park is very straightforward: Basic
4402 * operations on Win32 Events turn out to have the right semantics to
4403 * use them directly. We opportunistically resuse the event inherited
4404 * from Monitor.
4405 */
4408 void Parker::park(bool isAbsolute, jlong time) {
4409 guarantee (_ParkEvent != NULL, "invariant") ;
4410 // First, demultiplex/decode time arguments
4411 if (time < 0) { // don't wait
4412 return;
4413 }
4414 else if (time == 0 && !isAbsolute) {
4415 time = INFINITE;
4416 }
4417 else if (isAbsolute) {
4418 time -= os::javaTimeMillis(); // convert to relative time
4419 if (time <= 0) // already elapsed
4420 return;
4421 }
4422 else { // relative
4423 time /= 1000000; // Must coarsen from nanos to millis
4424 if (time == 0) // Wait for the minimal time unit if zero
4425 time = 1;
4426 }
4428 JavaThread* thread = (JavaThread*)(Thread::current());
4429 assert(thread->is_Java_thread(), "Must be JavaThread");
4430 JavaThread *jt = (JavaThread *)thread;
4432 // Don't wait if interrupted or already triggered
4433 if (Thread::is_interrupted(thread, false) ||
4434 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4435 ResetEvent(_ParkEvent);
4436 return;
4437 }
4438 else {
4439 ThreadBlockInVM tbivm(jt);
4440 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4441 jt->set_suspend_equivalent();
4443 WaitForSingleObject(_ParkEvent, time);
4444 ResetEvent(_ParkEvent);
4446 // If externally suspended while waiting, re-suspend
4447 if (jt->handle_special_suspend_equivalent_condition()) {
4448 jt->java_suspend_self();
4449 }
4450 }
4451 }
4453 void Parker::unpark() {
4454 guarantee (_ParkEvent != NULL, "invariant") ;
4455 SetEvent(_ParkEvent);
4456 }
4458 // Run the specified command in a separate process. Return its exit value,
4459 // or -1 on failure (e.g. can't create a new process).
4460 int os::fork_and_exec(char* cmd) {
4461 STARTUPINFO si;
4462 PROCESS_INFORMATION pi;
4464 memset(&si, 0, sizeof(si));
4465 si.cb = sizeof(si);
4466 memset(&pi, 0, sizeof(pi));
4467 BOOL rslt = CreateProcess(NULL, // executable name - use command line
4468 cmd, // command line
4469 NULL, // process security attribute
4470 NULL, // thread security attribute
4471 TRUE, // inherits system handles
4472 0, // no creation flags
4473 NULL, // use parent's environment block
4474 NULL, // use parent's starting directory
4475 &si, // (in) startup information
4476 &pi); // (out) process information
4478 if (rslt) {
4479 // Wait until child process exits.
4480 WaitForSingleObject(pi.hProcess, INFINITE);
4482 DWORD exit_code;
4483 GetExitCodeProcess(pi.hProcess, &exit_code);
4485 // Close process and thread handles.
4486 CloseHandle(pi.hProcess);
4487 CloseHandle(pi.hThread);
4489 return (int)exit_code;
4490 } else {
4491 return -1;
4492 }
4493 }
4495 //--------------------------------------------------------------------------------------------------
4496 // Non-product code
4498 static int mallocDebugIntervalCounter = 0;
4499 static int mallocDebugCounter = 0;
4500 bool os::check_heap(bool force) {
4501 if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4502 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4503 // Note: HeapValidate executes two hardware breakpoints when it finds something
4504 // wrong; at these points, eax contains the address of the offending block (I think).
4505 // To get to the exlicit error message(s) below, just continue twice.
4506 HANDLE heap = GetProcessHeap();
4507 { HeapLock(heap);
4508 PROCESS_HEAP_ENTRY phe;
4509 phe.lpData = NULL;
4510 while (HeapWalk(heap, &phe) != 0) {
4511 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4512 !HeapValidate(heap, 0, phe.lpData)) {
4513 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4514 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4515 fatal("corrupted C heap");
4516 }
4517 }
4518 int err = GetLastError();
4519 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4520 fatal(err_msg("heap walk aborted with error %d", err));
4521 }
4522 HeapUnlock(heap);
4523 }
4524 mallocDebugIntervalCounter = 0;
4525 }
4526 return true;
4527 }
4530 bool os::find(address addr, outputStream* st) {
4531 // Nothing yet
4532 return false;
4533 }
4535 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4536 DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4538 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4539 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4540 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4541 address addr = (address) exceptionRecord->ExceptionInformation[1];
4543 if (os::is_memory_serialize_page(thread, addr))
4544 return EXCEPTION_CONTINUE_EXECUTION;
4545 }
4547 return EXCEPTION_CONTINUE_SEARCH;
4548 }
4550 static int getLastErrorString(char *buf, size_t len)
4551 {
4552 long errval;
4554 if ((errval = GetLastError()) != 0)
4555 {
4556 /* DOS error */
4557 size_t n = (size_t)FormatMessage(
4558 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
4559 NULL,
4560 errval,
4561 0,
4562 buf,
4563 (DWORD)len,
4564 NULL);
4565 if (n > 3) {
4566 /* Drop final '.', CR, LF */
4567 if (buf[n - 1] == '\n') n--;
4568 if (buf[n - 1] == '\r') n--;
4569 if (buf[n - 1] == '.') n--;
4570 buf[n] = '\0';
4571 }
4572 return (int)n;
4573 }
4575 if (errno != 0)
4576 {
4577 /* C runtime error that has no corresponding DOS error code */
4578 const char *s = strerror(errno);
4579 size_t n = strlen(s);
4580 if (n >= len) n = len - 1;
4581 strncpy(buf, s, n);
4582 buf[n] = '\0';
4583 return (int)n;
4584 }
4585 return 0;
4586 }
4589 // We don't build a headless jre for Windows
4590 bool os::is_headless_jre() { return false; }
4592 // OS_SocketInterface
4593 // Not used on Windows
4595 // OS_SocketInterface
4596 typedef struct hostent * (PASCAL FAR *ws2_ifn_ptr_t)(...);
4597 ws2_ifn_ptr_t *get_host_by_name_fn = NULL;
4599 typedef CRITICAL_SECTION mutex_t;
4600 #define mutexInit(m) InitializeCriticalSection(m)
4601 #define mutexDestroy(m) DeleteCriticalSection(m)
4602 #define mutexLock(m) EnterCriticalSection(m)
4603 #define mutexUnlock(m) LeaveCriticalSection(m)
4605 static bool sockfnptrs_initialized = FALSE;
4606 static mutex_t sockFnTableMutex;
4608 /* is Winsock2 loaded? better to be explicit than to rely on sockfnptrs */
4609 static bool winsock2Available = FALSE;
4612 static void initSockFnTable() {
4613 int (PASCAL FAR* WSAStartupPtr)(WORD, LPWSADATA);
4614 WSADATA wsadata;
4616 ::mutexInit(&sockFnTableMutex);
4617 ::mutexLock(&sockFnTableMutex);
4619 if (sockfnptrs_initialized == FALSE) {
4620 HMODULE hWinsock;
4622 /* try to load Winsock2, and if that fails, load Winsock */
4623 hWinsock = ::LoadLibrary("ws2_32.dll");
4625 if (hWinsock == NULL) {
4626 jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4627 ::GetLastError());
4628 return;
4629 }
4631 /* If we loaded a DLL, then we might as well initialize it. */
4632 WSAStartupPtr = (int (PASCAL FAR *)(WORD, LPWSADATA))
4633 ::GetProcAddress(hWinsock, "WSAStartup");
4635 if (WSAStartupPtr(MAKEWORD(1,1), &wsadata) != 0) {
4636 jio_fprintf(stderr, "Could not initialize Winsock\n");
4637 }
4639 get_host_by_name_fn
4640 = (ws2_ifn_ptr_t*) GetProcAddress(hWinsock, "gethostbyname");
4641 }
4643 assert(get_host_by_name_fn != NULL,
4644 "gethostbyname function not found");
4645 sockfnptrs_initialized = TRUE;
4646 ::mutexUnlock(&sockFnTableMutex);
4647 }
4649 struct hostent* os::get_host_by_name(char* name) {
4650 if (!sockfnptrs_initialized) {
4651 initSockFnTable();
4652 }
4654 assert(sockfnptrs_initialized == TRUE && get_host_by_name_fn != NULL,
4655 "sockfnptrs is not initialized or pointer to gethostbyname function is NULL");
4656 return (*get_host_by_name_fn)(name);
4657 }
4660 int os::socket_close(int fd) {
4661 ShouldNotReachHere();
4662 return 0;
4663 }
4665 int os::socket_available(int fd, jint *pbytes) {
4666 ShouldNotReachHere();
4667 return 0;
4668 }
4670 int os::socket(int domain, int type, int protocol) {
4671 ShouldNotReachHere();
4672 return 0;
4673 }
4675 int os::listen(int fd, int count) {
4676 ShouldNotReachHere();
4677 return 0;
4678 }
4680 int os::connect(int fd, struct sockaddr *him, int len) {
4681 ShouldNotReachHere();
4682 return 0;
4683 }
4685 int os::accept(int fd, struct sockaddr *him, int *len) {
4686 ShouldNotReachHere();
4687 return 0;
4688 }
4690 int os::sendto(int fd, char *buf, int len, int flags,
4691 struct sockaddr *to, int tolen) {
4692 ShouldNotReachHere();
4693 return 0;
4694 }
4696 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
4697 sockaddr *from, int *fromlen) {
4698 ShouldNotReachHere();
4699 return 0;
4700 }
4702 int os::recv(int fd, char *buf, int nBytes, int flags) {
4703 ShouldNotReachHere();
4704 return 0;
4705 }
4707 int os::send(int fd, char *buf, int nBytes, int flags) {
4708 ShouldNotReachHere();
4709 return 0;
4710 }
4712 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
4713 ShouldNotReachHere();
4714 return 0;
4715 }
4717 int os::timeout(int fd, long timeout) {
4718 ShouldNotReachHere();
4719 return 0;
4720 }
4722 int os::get_host_name(char* name, int namelen) {
4723 ShouldNotReachHere();
4724 return 0;
4725 }
4727 int os::socket_shutdown(int fd, int howto) {
4728 ShouldNotReachHere();
4729 return 0;
4730 }
4732 int os::bind(int fd, struct sockaddr *him, int len) {
4733 ShouldNotReachHere();
4734 return 0;
4735 }
4737 int os::get_sock_name(int fd, struct sockaddr *him, int *len) {
4738 ShouldNotReachHere();
4739 return 0;
4740 }
4742 int os::get_sock_opt(int fd, int level, int optname,
4743 char *optval, int* optlen) {
4744 ShouldNotReachHere();
4745 return 0;
4746 }
4748 int os::set_sock_opt(int fd, int level, int optname,
4749 const char *optval, int optlen) {
4750 ShouldNotReachHere();
4751 return 0;
4752 }