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