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