Mon, 17 Jun 2019 16:41:38 +0100
8202353: os::readdir should use readdir instead of readdir_r
Summary: Summary: os::readdir uses POSIX readdir, drop buffer arg, fix JFR uses.
Reviewed-by: coleenp, tschatzl, bsrbnd, shade, phh
1 /*
2 * Copyright (c) 1997, 2019, 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 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 "compiler/disassembler.hpp"
36 #include "interpreter/interpreter.hpp"
37 #include "jvm_windows.h"
38 #include "memory/allocation.inline.hpp"
39 #include "memory/filemap.hpp"
40 #include "mutex_windows.inline.hpp"
41 #include "oops/oop.inline.hpp"
42 #include "os_share_windows.hpp"
43 #include "prims/jniFastGetField.hpp"
44 #include "prims/jvm.h"
45 #include "prims/jvm_misc.hpp"
46 #include "runtime/arguments.hpp"
47 #include "runtime/extendedPC.hpp"
48 #include "runtime/globals.hpp"
49 #include "runtime/interfaceSupport.hpp"
50 #include "runtime/java.hpp"
51 #include "runtime/javaCalls.hpp"
52 #include "runtime/mutexLocker.hpp"
53 #include "runtime/objectMonitor.hpp"
54 #include "runtime/orderAccess.inline.hpp"
55 #include "runtime/osThread.hpp"
56 #include "runtime/perfMemory.hpp"
57 #include "runtime/sharedRuntime.hpp"
58 #include "runtime/statSampler.hpp"
59 #include "runtime/stubRoutines.hpp"
60 #include "runtime/thread.inline.hpp"
61 #include "runtime/threadCritical.hpp"
62 #include "runtime/timer.hpp"
63 #include "services/attachListener.hpp"
64 #include "services/memTracker.hpp"
65 #include "services/runtimeService.hpp"
66 #include "utilities/decoder.hpp"
67 #include "utilities/defaultStream.hpp"
68 #include "utilities/events.hpp"
69 #include "utilities/growableArray.hpp"
70 #include "utilities/vmError.hpp"
72 #ifdef _DEBUG
73 #include <crtdbg.h>
74 #endif
77 #include <windows.h>
78 #include <sys/types.h>
79 #include <sys/stat.h>
80 #include <sys/timeb.h>
81 #include <objidl.h>
82 #include <shlobj.h>
84 #include <malloc.h>
85 #include <signal.h>
86 #include <direct.h>
87 #include <errno.h>
88 #include <fcntl.h>
89 #include <io.h>
90 #include <process.h> // For _beginthreadex(), _endthreadex()
91 #include <imagehlp.h> // For os::dll_address_to_function_name
92 /* for enumerating dll libraries */
93 #include <vdmdbg.h>
95 // for timer info max values which include all bits
96 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
98 // For DLL loading/load error detection
99 // Values of PE COFF
100 #define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c
101 #define IMAGE_FILE_SIGNATURE_LENGTH 4
103 static HANDLE main_process;
104 static HANDLE main_thread;
105 static int main_thread_id;
107 static FILETIME process_creation_time;
108 static FILETIME process_exit_time;
109 static FILETIME process_user_time;
110 static FILETIME process_kernel_time;
112 #ifdef _M_IA64
113 #define __CPU__ ia64
114 #else
115 #ifdef _M_AMD64
116 #define __CPU__ amd64
117 #else
118 #define __CPU__ i486
119 #endif
120 #endif
122 // save DLL module handle, used by GetModuleFileName
124 HINSTANCE vm_lib_handle;
126 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
127 switch (reason) {
128 case DLL_PROCESS_ATTACH:
129 vm_lib_handle = hinst;
130 if(ForceTimeHighResolution)
131 timeBeginPeriod(1L);
132 break;
133 case DLL_PROCESS_DETACH:
134 if(ForceTimeHighResolution)
135 timeEndPeriod(1L);
137 break;
138 default:
139 break;
140 }
141 return true;
142 }
144 static inline double fileTimeAsDouble(FILETIME* time) {
145 const double high = (double) ((unsigned int) ~0);
146 const double split = 10000000.0;
147 double result = (time->dwLowDateTime / split) +
148 time->dwHighDateTime * (high/split);
149 return result;
150 }
152 // Implementation of os
154 bool os::getenv(const char* name, char* buffer, int len) {
155 int result = GetEnvironmentVariable(name, buffer, len);
156 return result > 0 && result < len;
157 }
159 bool os::unsetenv(const char* name) {
160 assert(name != NULL, "Null pointer");
161 return (SetEnvironmentVariable(name, NULL) == TRUE);
162 }
164 // No setuid programs under Windows.
165 bool os::have_special_privileges() {
166 return false;
167 }
170 // This method is a periodic task to check for misbehaving JNI applications
171 // under CheckJNI, we can add any periodic checks here.
172 // For Windows at the moment does nothing
173 void os::run_periodic_checks() {
174 return;
175 }
177 #ifndef _WIN64
178 // previous UnhandledExceptionFilter, if there is one
179 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
181 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
182 #endif
183 void os::init_system_properties_values() {
184 /* sysclasspath, java_home, dll_dir */
185 {
186 char *home_path;
187 char *dll_path;
188 char *pslash;
189 char *bin = "\\bin";
190 char home_dir[MAX_PATH];
192 if (!getenv("_ALT_JAVA_HOME_DIR", home_dir, MAX_PATH)) {
193 os::jvm_path(home_dir, sizeof(home_dir));
194 // Found the full path to jvm.dll.
195 // Now cut the path to <java_home>/jre if we can.
196 *(strrchr(home_dir, '\\')) = '\0'; /* get rid of \jvm.dll */
197 pslash = strrchr(home_dir, '\\');
198 if (pslash != NULL) {
199 *pslash = '\0'; /* get rid of \{client|server} */
200 pslash = strrchr(home_dir, '\\');
201 if (pslash != NULL)
202 *pslash = '\0'; /* get rid of \bin */
203 }
204 }
206 home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal);
207 if (home_path == NULL)
208 return;
209 strcpy(home_path, home_dir);
210 Arguments::set_java_home(home_path);
212 dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1, mtInternal);
213 if (dll_path == NULL)
214 return;
215 strcpy(dll_path, home_dir);
216 strcat(dll_path, bin);
217 Arguments::set_dll_dir(dll_path);
219 if (!set_boot_path('\\', ';'))
220 return;
221 }
223 /* library_path */
224 #define EXT_DIR "\\lib\\ext"
225 #define BIN_DIR "\\bin"
226 #define PACKAGE_DIR "\\Sun\\Java"
227 {
228 /* Win32 library search order (See the documentation for LoadLibrary):
229 *
230 * 1. The directory from which application is loaded.
231 * 2. The system wide Java Extensions directory (Java only)
232 * 3. System directory (GetSystemDirectory)
233 * 4. Windows directory (GetWindowsDirectory)
234 * 5. The PATH environment variable
235 * 6. The current directory
236 */
238 char *library_path;
239 char tmp[MAX_PATH];
240 char *path_str = ::getenv("PATH");
242 library_path = NEW_C_HEAP_ARRAY(char, MAX_PATH * 5 + sizeof(PACKAGE_DIR) +
243 sizeof(BIN_DIR) + (path_str ? strlen(path_str) : 0) + 10, mtInternal);
245 library_path[0] = '\0';
247 GetModuleFileName(NULL, tmp, sizeof(tmp));
248 *(strrchr(tmp, '\\')) = '\0';
249 strcat(library_path, tmp);
251 GetWindowsDirectory(tmp, sizeof(tmp));
252 strcat(library_path, ";");
253 strcat(library_path, tmp);
254 strcat(library_path, PACKAGE_DIR BIN_DIR);
256 GetSystemDirectory(tmp, sizeof(tmp));
257 strcat(library_path, ";");
258 strcat(library_path, tmp);
260 GetWindowsDirectory(tmp, sizeof(tmp));
261 strcat(library_path, ";");
262 strcat(library_path, tmp);
264 if (path_str) {
265 strcat(library_path, ";");
266 strcat(library_path, path_str);
267 }
269 strcat(library_path, ";.");
271 Arguments::set_library_path(library_path);
272 FREE_C_HEAP_ARRAY(char, library_path, mtInternal);
273 }
275 /* Default extensions directory */
276 {
277 char path[MAX_PATH];
278 char buf[2 * MAX_PATH + 2 * sizeof(EXT_DIR) + sizeof(PACKAGE_DIR) + 1];
279 GetWindowsDirectory(path, MAX_PATH);
280 sprintf(buf, "%s%s;%s%s%s", Arguments::get_java_home(), EXT_DIR,
281 path, PACKAGE_DIR, EXT_DIR);
282 Arguments::set_ext_dirs(buf);
283 }
284 #undef EXT_DIR
285 #undef BIN_DIR
286 #undef PACKAGE_DIR
288 /* Default endorsed standards directory. */
289 {
290 #define ENDORSED_DIR "\\lib\\endorsed"
291 size_t len = strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR);
292 char * buf = NEW_C_HEAP_ARRAY(char, len, mtInternal);
293 sprintf(buf, "%s%s", Arguments::get_java_home(), ENDORSED_DIR);
294 Arguments::set_endorsed_dirs(buf);
295 #undef ENDORSED_DIR
296 }
298 #ifndef _WIN64
299 // set our UnhandledExceptionFilter and save any previous one
300 prev_uef_handler = SetUnhandledExceptionFilter(Handle_FLT_Exception);
301 #endif
303 // Done
304 return;
305 }
307 void os::breakpoint() {
308 DebugBreak();
309 }
311 // Invoked from the BREAKPOINT Macro
312 extern "C" void breakpoint() {
313 os::breakpoint();
314 }
316 /*
317 * RtlCaptureStackBackTrace Windows API may not exist prior to Windows XP.
318 * So far, this method is only used by Native Memory Tracking, which is
319 * only supported on Windows XP or later.
320 */
322 int os::get_native_stack(address* stack, int frames, int toSkip) {
323 #ifdef _NMT_NOINLINE_
324 toSkip ++;
325 #endif
326 int captured = Kernel32Dll::RtlCaptureStackBackTrace(toSkip + 1, frames,
327 (PVOID*)stack, NULL);
328 for (int index = captured; index < frames; index ++) {
329 stack[index] = NULL;
330 }
331 return captured;
332 }
335 // os::current_stack_base()
336 //
337 // Returns the base of the stack, which is the stack's
338 // starting address. This function must be called
339 // while running on the stack of the thread being queried.
341 address os::current_stack_base() {
342 MEMORY_BASIC_INFORMATION minfo;
343 address stack_bottom;
344 size_t stack_size;
346 VirtualQuery(&minfo, &minfo, sizeof(minfo));
347 stack_bottom = (address)minfo.AllocationBase;
348 stack_size = minfo.RegionSize;
350 // Add up the sizes of all the regions with the same
351 // AllocationBase.
352 while( 1 )
353 {
354 VirtualQuery(stack_bottom+stack_size, &minfo, sizeof(minfo));
355 if ( stack_bottom == (address)minfo.AllocationBase )
356 stack_size += minfo.RegionSize;
357 else
358 break;
359 }
361 #ifdef _M_IA64
362 // IA64 has memory and register stacks
363 //
364 // This is the stack layout you get on NT/IA64 if you specify 1MB stack limit
365 // at thread creation (1MB backing store growing upwards, 1MB memory stack
366 // growing downwards, 2MB summed up)
367 //
368 // ...
369 // ------- top of stack (high address) -----
370 // |
371 // | 1MB
372 // | Backing Store (Register Stack)
373 // |
374 // | / \
375 // | |
376 // | |
377 // | |
378 // ------------------------ stack base -----
379 // | 1MB
380 // | Memory Stack
381 // |
382 // | |
383 // | |
384 // | |
385 // | \ /
386 // |
387 // ----- bottom of stack (low address) -----
388 // ...
390 stack_size = stack_size / 2;
391 #endif
392 return stack_bottom + stack_size;
393 }
395 size_t os::current_stack_size() {
396 size_t sz;
397 MEMORY_BASIC_INFORMATION minfo;
398 VirtualQuery(&minfo, &minfo, sizeof(minfo));
399 sz = (size_t)os::current_stack_base() - (size_t)minfo.AllocationBase;
400 return sz;
401 }
403 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
404 const struct tm* time_struct_ptr = localtime(clock);
405 if (time_struct_ptr != NULL) {
406 *res = *time_struct_ptr;
407 return res;
408 }
409 return NULL;
410 }
412 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
414 // Thread start routine for all new Java threads
415 static unsigned __stdcall java_start(Thread* thread) {
416 // Try to randomize the cache line index of hot stack frames.
417 // This helps when threads of the same stack traces evict each other's
418 // cache lines. The threads can be either from the same JVM instance, or
419 // from different JVM instances. The benefit is especially true for
420 // processors with hyperthreading technology.
421 static int counter = 0;
422 int pid = os::current_process_id();
423 _alloca(((pid ^ counter++) & 7) * 128);
425 OSThread* osthr = thread->osthread();
426 assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
428 if (UseNUMA) {
429 int lgrp_id = os::numa_get_group_id();
430 if (lgrp_id != -1) {
431 thread->set_lgrp_id(lgrp_id);
432 }
433 }
436 // Install a win32 structured exception handler around every thread created
437 // by VM, so VM can genrate error dump when an exception occurred in non-
438 // Java thread (e.g. VM thread).
439 __try {
440 thread->run();
441 } __except(topLevelExceptionFilter(
442 (_EXCEPTION_POINTERS*)_exception_info())) {
443 // Nothing to do.
444 }
446 // One less thread is executing
447 // When the VMThread gets here, the main thread may have already exited
448 // which frees the CodeHeap containing the Atomic::add code
449 if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
450 Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count);
451 }
453 return 0;
454 }
456 static OSThread* create_os_thread(Thread* thread, HANDLE thread_handle, int thread_id) {
457 // Allocate the OSThread object
458 OSThread* osthread = new OSThread(NULL, NULL);
459 if (osthread == NULL) return NULL;
461 // Initialize support for Java interrupts
462 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
463 if (interrupt_event == NULL) {
464 delete osthread;
465 return NULL;
466 }
467 osthread->set_interrupt_event(interrupt_event);
469 // Store info on the Win32 thread into the OSThread
470 osthread->set_thread_handle(thread_handle);
471 osthread->set_thread_id(thread_id);
473 if (UseNUMA) {
474 int lgrp_id = os::numa_get_group_id();
475 if (lgrp_id != -1) {
476 thread->set_lgrp_id(lgrp_id);
477 }
478 }
480 // Initial thread state is INITIALIZED, not SUSPENDED
481 osthread->set_state(INITIALIZED);
483 return osthread;
484 }
487 bool os::create_attached_thread(JavaThread* thread) {
488 #ifdef ASSERT
489 thread->verify_not_published();
490 #endif
491 HANDLE thread_h;
492 if (!DuplicateHandle(main_process, GetCurrentThread(), GetCurrentProcess(),
493 &thread_h, THREAD_ALL_ACCESS, false, 0)) {
494 fatal("DuplicateHandle failed\n");
495 }
496 OSThread* osthread = create_os_thread(thread, thread_h,
497 (int)current_thread_id());
498 if (osthread == NULL) {
499 return false;
500 }
502 // Initial thread state is RUNNABLE
503 osthread->set_state(RUNNABLE);
505 thread->set_osthread(osthread);
506 return true;
507 }
509 bool os::create_main_thread(JavaThread* thread) {
510 #ifdef ASSERT
511 thread->verify_not_published();
512 #endif
513 if (_starting_thread == NULL) {
514 _starting_thread = create_os_thread(thread, main_thread, main_thread_id);
515 if (_starting_thread == NULL) {
516 return false;
517 }
518 }
520 // The primordial thread is runnable from the start)
521 _starting_thread->set_state(RUNNABLE);
523 thread->set_osthread(_starting_thread);
524 return true;
525 }
527 // Allocate and initialize a new OSThread
528 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
529 unsigned thread_id;
531 // Allocate the OSThread object
532 OSThread* osthread = new OSThread(NULL, NULL);
533 if (osthread == NULL) {
534 return false;
535 }
537 // Initialize support for Java interrupts
538 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
539 if (interrupt_event == NULL) {
540 delete osthread;
541 return NULL;
542 }
543 osthread->set_interrupt_event(interrupt_event);
544 osthread->set_interrupted(false);
546 thread->set_osthread(osthread);
548 if (stack_size == 0) {
549 switch (thr_type) {
550 case os::java_thread:
551 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
552 if (JavaThread::stack_size_at_create() > 0)
553 stack_size = JavaThread::stack_size_at_create();
554 break;
555 case os::compiler_thread:
556 if (CompilerThreadStackSize > 0) {
557 stack_size = (size_t)(CompilerThreadStackSize * K);
558 break;
559 } // else fall through:
560 // use VMThreadStackSize if CompilerThreadStackSize is not defined
561 case os::vm_thread:
562 case os::pgc_thread:
563 case os::cgc_thread:
564 case os::watcher_thread:
565 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
566 break;
567 }
568 }
570 // Create the Win32 thread
571 //
572 // Contrary to what MSDN document says, "stack_size" in _beginthreadex()
573 // does not specify stack size. Instead, it specifies the size of
574 // initially committed space. The stack size is determined by
575 // PE header in the executable. If the committed "stack_size" is larger
576 // than default value in the PE header, the stack is rounded up to the
577 // nearest multiple of 1MB. For example if the launcher has default
578 // stack size of 320k, specifying any size less than 320k does not
579 // affect the actual stack size at all, it only affects the initial
580 // commitment. On the other hand, specifying 'stack_size' larger than
581 // default value may cause significant increase in memory usage, because
582 // not only the stack space will be rounded up to MB, but also the
583 // entire space is committed upfront.
584 //
585 // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION'
586 // for CreateThread() that can treat 'stack_size' as stack size. However we
587 // are not supposed to call CreateThread() directly according to MSDN
588 // document because JVM uses C runtime library. The good news is that the
589 // flag appears to work with _beginthredex() as well.
591 #ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
592 #define STACK_SIZE_PARAM_IS_A_RESERVATION (0x10000)
593 #endif
595 HANDLE thread_handle =
596 (HANDLE)_beginthreadex(NULL,
597 (unsigned)stack_size,
598 (unsigned (__stdcall *)(void*)) java_start,
599 thread,
600 CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION,
601 &thread_id);
602 if (thread_handle == NULL) {
603 // perhaps STACK_SIZE_PARAM_IS_A_RESERVATION is not supported, try again
604 // without the flag.
605 thread_handle =
606 (HANDLE)_beginthreadex(NULL,
607 (unsigned)stack_size,
608 (unsigned (__stdcall *)(void*)) java_start,
609 thread,
610 CREATE_SUSPENDED,
611 &thread_id);
612 }
613 if (thread_handle == NULL) {
614 // Need to clean up stuff we've allocated so far
615 CloseHandle(osthread->interrupt_event());
616 thread->set_osthread(NULL);
617 delete osthread;
618 return NULL;
619 }
621 Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
623 // Store info on the Win32 thread into the OSThread
624 osthread->set_thread_handle(thread_handle);
625 osthread->set_thread_id(thread_id);
627 // Initial thread state is INITIALIZED, not SUSPENDED
628 osthread->set_state(INITIALIZED);
630 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
631 return true;
632 }
635 // Free Win32 resources related to the OSThread
636 void os::free_thread(OSThread* osthread) {
637 assert(osthread != NULL, "osthread not set");
638 CloseHandle(osthread->thread_handle());
639 CloseHandle(osthread->interrupt_event());
640 delete osthread;
641 }
644 static int has_performance_count = 0;
645 static jlong first_filetime;
646 static jlong initial_performance_count;
647 static jlong performance_frequency;
650 jlong as_long(LARGE_INTEGER x) {
651 jlong result = 0; // initialization to avoid warning
652 set_high(&result, x.HighPart);
653 set_low(&result, x.LowPart);
654 return result;
655 }
658 jlong os::elapsed_counter() {
659 LARGE_INTEGER count;
660 if (has_performance_count) {
661 QueryPerformanceCounter(&count);
662 return as_long(count) - initial_performance_count;
663 } else {
664 FILETIME wt;
665 GetSystemTimeAsFileTime(&wt);
666 return (jlong_from(wt.dwHighDateTime, wt.dwLowDateTime) - first_filetime);
667 }
668 }
671 jlong os::elapsed_frequency() {
672 if (has_performance_count) {
673 return performance_frequency;
674 } else {
675 // the FILETIME time is the number of 100-nanosecond intervals since January 1,1601.
676 return 10000000;
677 }
678 }
681 julong os::available_memory() {
682 return win32::available_memory();
683 }
685 julong os::win32::available_memory() {
686 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
687 // value if total memory is larger than 4GB
688 MEMORYSTATUSEX ms;
689 ms.dwLength = sizeof(ms);
690 GlobalMemoryStatusEx(&ms);
692 return (julong)ms.ullAvailPhys;
693 }
695 julong os::physical_memory() {
696 return win32::physical_memory();
697 }
699 bool os::has_allocatable_memory_limit(julong* limit) {
700 MEMORYSTATUSEX ms;
701 ms.dwLength = sizeof(ms);
702 GlobalMemoryStatusEx(&ms);
703 #ifdef _LP64
704 *limit = (julong)ms.ullAvailVirtual;
705 return true;
706 #else
707 // Limit to 1400m because of the 2gb address space wall
708 *limit = MIN2((julong)1400*M, (julong)ms.ullAvailVirtual);
709 return true;
710 #endif
711 }
713 // VC6 lacks DWORD_PTR
714 #if _MSC_VER < 1300
715 typedef UINT_PTR DWORD_PTR;
716 #endif
718 int os::active_processor_count() {
719 // User has overridden the number of active processors
720 if (ActiveProcessorCount > 0) {
721 if (PrintActiveCpus) {
722 tty->print_cr("active_processor_count: "
723 "active processor count set by user : %d",
724 ActiveProcessorCount);
725 }
726 return ActiveProcessorCount;
727 }
729 DWORD_PTR lpProcessAffinityMask = 0;
730 DWORD_PTR lpSystemAffinityMask = 0;
731 int proc_count = processor_count();
732 if (proc_count <= sizeof(UINT_PTR) * BitsPerByte &&
733 GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) {
734 // Nof active processors is number of bits in process affinity mask
735 int bitcount = 0;
736 while (lpProcessAffinityMask != 0) {
737 lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1);
738 bitcount++;
739 }
740 return bitcount;
741 } else {
742 return proc_count;
743 }
744 }
746 void os::set_native_thread_name(const char *name) {
748 // See: http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
749 //
750 // Note that unfortunately this only works if the process
751 // is already attached to a debugger; debugger must observe
752 // the exception below to show the correct name.
754 const DWORD MS_VC_EXCEPTION = 0x406D1388;
755 struct {
756 DWORD dwType; // must be 0x1000
757 LPCSTR szName; // pointer to name (in user addr space)
758 DWORD dwThreadID; // thread ID (-1=caller thread)
759 DWORD dwFlags; // reserved for future use, must be zero
760 } info;
762 info.dwType = 0x1000;
763 info.szName = name;
764 info.dwThreadID = -1;
765 info.dwFlags = 0;
767 __try {
768 RaiseException (MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(DWORD), (const ULONG_PTR*)&info );
769 } __except(EXCEPTION_CONTINUE_EXECUTION) {}
770 }
772 bool os::distribute_processes(uint length, uint* distribution) {
773 // Not yet implemented.
774 return false;
775 }
777 bool os::bind_to_processor(uint processor_id) {
778 // Not yet implemented.
779 return false;
780 }
782 static void initialize_performance_counter() {
783 LARGE_INTEGER count;
784 if (QueryPerformanceFrequency(&count)) {
785 has_performance_count = 1;
786 performance_frequency = as_long(count);
787 QueryPerformanceCounter(&count);
788 initial_performance_count = as_long(count);
789 } else {
790 has_performance_count = 0;
791 FILETIME wt;
792 GetSystemTimeAsFileTime(&wt);
793 first_filetime = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
794 }
795 }
798 double os::elapsedTime() {
799 return (double) elapsed_counter() / (double) elapsed_frequency();
800 }
803 // Windows format:
804 // The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601.
805 // Java format:
806 // Java standards require the number of milliseconds since 1/1/1970
808 // Constant offset - calculated using offset()
809 static jlong _offset = 116444736000000000;
810 // Fake time counter for reproducible results when debugging
811 static jlong fake_time = 0;
813 #ifdef ASSERT
814 // Just to be safe, recalculate the offset in debug mode
815 static jlong _calculated_offset = 0;
816 static int _has_calculated_offset = 0;
818 jlong offset() {
819 if (_has_calculated_offset) return _calculated_offset;
820 SYSTEMTIME java_origin;
821 java_origin.wYear = 1970;
822 java_origin.wMonth = 1;
823 java_origin.wDayOfWeek = 0; // ignored
824 java_origin.wDay = 1;
825 java_origin.wHour = 0;
826 java_origin.wMinute = 0;
827 java_origin.wSecond = 0;
828 java_origin.wMilliseconds = 0;
829 FILETIME jot;
830 if (!SystemTimeToFileTime(&java_origin, &jot)) {
831 fatal(err_msg("Error = %d\nWindows error", GetLastError()));
832 }
833 _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime);
834 _has_calculated_offset = 1;
835 assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal");
836 return _calculated_offset;
837 }
838 #else
839 jlong offset() {
840 return _offset;
841 }
842 #endif
844 jlong windows_to_java_time(FILETIME wt) {
845 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
846 return (a - offset()) / 10000;
847 }
849 FILETIME java_to_windows_time(jlong l) {
850 jlong a = (l * 10000) + offset();
851 FILETIME result;
852 result.dwHighDateTime = high(a);
853 result.dwLowDateTime = low(a);
854 return result;
855 }
857 bool os::supports_vtime() { return true; }
858 bool os::enable_vtime() { return false; }
859 bool os::vtime_enabled() { return false; }
861 double os::elapsedVTime() {
862 FILETIME created;
863 FILETIME exited;
864 FILETIME kernel;
865 FILETIME user;
866 if (GetThreadTimes(GetCurrentThread(), &created, &exited, &kernel, &user) != 0) {
867 // the resolution of windows_to_java_time() should be sufficient (ms)
868 return (double) (windows_to_java_time(kernel) + windows_to_java_time(user)) / MILLIUNITS;
869 } else {
870 return elapsedTime();
871 }
872 }
874 jlong os::javaTimeMillis() {
875 if (UseFakeTimers) {
876 return fake_time++;
877 } else {
878 FILETIME wt;
879 GetSystemTimeAsFileTime(&wt);
880 return windows_to_java_time(wt);
881 }
882 }
884 jlong os::javaTimeNanos() {
885 if (!has_performance_count) {
886 return javaTimeMillis() * NANOSECS_PER_MILLISEC; // the best we can do.
887 } else {
888 LARGE_INTEGER current_count;
889 QueryPerformanceCounter(¤t_count);
890 double current = as_long(current_count);
891 double freq = performance_frequency;
892 jlong time = (jlong)((current/freq) * NANOSECS_PER_SEC);
893 return time;
894 }
895 }
897 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
898 if (!has_performance_count) {
899 // javaTimeMillis() doesn't have much percision,
900 // but it is not going to wrap -- so all 64 bits
901 info_ptr->max_value = ALL_64_BITS;
903 // this is a wall clock timer, so may skip
904 info_ptr->may_skip_backward = true;
905 info_ptr->may_skip_forward = true;
906 } else {
907 jlong freq = performance_frequency;
908 if (freq < NANOSECS_PER_SEC) {
909 // the performance counter is 64 bits and we will
910 // be multiplying it -- so no wrap in 64 bits
911 info_ptr->max_value = ALL_64_BITS;
912 } else if (freq > NANOSECS_PER_SEC) {
913 // use the max value the counter can reach to
914 // determine the max value which could be returned
915 julong max_counter = (julong)ALL_64_BITS;
916 info_ptr->max_value = (jlong)(max_counter / (freq / NANOSECS_PER_SEC));
917 } else {
918 // the performance counter is 64 bits and we will
919 // be using it directly -- so no wrap in 64 bits
920 info_ptr->max_value = ALL_64_BITS;
921 }
923 // using a counter, so no skipping
924 info_ptr->may_skip_backward = false;
925 info_ptr->may_skip_forward = false;
926 }
927 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time
928 }
930 char* os::local_time_string(char *buf, size_t buflen) {
931 SYSTEMTIME st;
932 GetLocalTime(&st);
933 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
934 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
935 return buf;
936 }
938 bool os::getTimesSecs(double* process_real_time,
939 double* process_user_time,
940 double* process_system_time) {
941 HANDLE h_process = GetCurrentProcess();
942 FILETIME create_time, exit_time, kernel_time, user_time;
943 BOOL result = GetProcessTimes(h_process,
944 &create_time,
945 &exit_time,
946 &kernel_time,
947 &user_time);
948 if (result != 0) {
949 FILETIME wt;
950 GetSystemTimeAsFileTime(&wt);
951 jlong rtc_millis = windows_to_java_time(wt);
952 jlong user_millis = windows_to_java_time(user_time);
953 jlong system_millis = windows_to_java_time(kernel_time);
954 *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS);
955 *process_user_time = ((double) user_millis) / ((double) MILLIUNITS);
956 *process_system_time = ((double) system_millis) / ((double) MILLIUNITS);
957 return true;
958 } else {
959 return false;
960 }
961 }
963 void os::shutdown() {
965 // allow PerfMemory to attempt cleanup of any persistent resources
966 perfMemory_exit();
968 // flush buffered output, finish log files
969 ostream_abort();
971 // Check for abort hook
972 abort_hook_t abort_hook = Arguments::abort_hook();
973 if (abort_hook != NULL) {
974 abort_hook();
975 }
976 }
979 static BOOL (WINAPI *_MiniDumpWriteDump) ( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
980 PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION);
982 void os::check_or_create_dump(void* exceptionRecord, void* contextRecord, char* buffer, size_t bufferSize) {
983 HINSTANCE dbghelp;
984 EXCEPTION_POINTERS ep;
985 MINIDUMP_EXCEPTION_INFORMATION mei;
986 MINIDUMP_EXCEPTION_INFORMATION* pmei;
988 HANDLE hProcess = GetCurrentProcess();
989 DWORD processId = GetCurrentProcessId();
990 HANDLE dumpFile;
991 MINIDUMP_TYPE dumpType;
992 static const char* cwd;
994 // Default is to always create dump for debug builds, on product builds only dump on server versions of Windows.
995 #ifndef ASSERT
996 // If running on a client version of Windows and user has not explicitly enabled dumping
997 if (!os::win32::is_windows_server() && !CreateMinidumpOnCrash) {
998 VMError::report_coredump_status("Minidumps are not enabled by default on client versions of Windows", false);
999 return;
1000 // If running on a server version of Windows and user has explictly disabled dumping
1001 } else if (os::win32::is_windows_server() && !FLAG_IS_DEFAULT(CreateMinidumpOnCrash) && !CreateMinidumpOnCrash) {
1002 VMError::report_coredump_status("Minidump has been disabled from the command line", false);
1003 return;
1004 }
1005 #else
1006 if (!FLAG_IS_DEFAULT(CreateMinidumpOnCrash) && !CreateMinidumpOnCrash) {
1007 VMError::report_coredump_status("Minidump has been disabled from the command line", false);
1008 return;
1009 }
1010 #endif
1012 dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0);
1014 if (dbghelp == NULL) {
1015 VMError::report_coredump_status("Failed to load dbghelp.dll", false);
1016 return;
1017 }
1019 _MiniDumpWriteDump = CAST_TO_FN_PTR(
1020 BOOL(WINAPI *)( HANDLE, DWORD, HANDLE, MINIDUMP_TYPE, PMINIDUMP_EXCEPTION_INFORMATION,
1021 PMINIDUMP_USER_STREAM_INFORMATION, PMINIDUMP_CALLBACK_INFORMATION),
1022 GetProcAddress(dbghelp, "MiniDumpWriteDump"));
1024 if (_MiniDumpWriteDump == NULL) {
1025 VMError::report_coredump_status("Failed to find MiniDumpWriteDump() in module dbghelp.dll", false);
1026 return;
1027 }
1029 dumpType = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | MiniDumpWithHandleData);
1031 // Older versions of dbghelp.h doesn't contain all the dumptypes we want, dbghelp.h with
1032 // API_VERSION_NUMBER 11 or higher contains the ones we want though
1033 #if API_VERSION_NUMBER >= 11
1034 dumpType = (MINIDUMP_TYPE)(dumpType | MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo |
1035 MiniDumpWithUnloadedModules);
1036 #endif
1038 cwd = get_current_directory(NULL, 0);
1039 jio_snprintf(buffer, bufferSize, "%s\\hs_err_pid%u.mdmp",cwd, current_process_id());
1040 dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
1042 if (dumpFile == INVALID_HANDLE_VALUE) {
1043 VMError::report_coredump_status("Failed to create file for dumping", false);
1044 return;
1045 }
1046 if (exceptionRecord != NULL && contextRecord != NULL) {
1047 ep.ContextRecord = (PCONTEXT) contextRecord;
1048 ep.ExceptionRecord = (PEXCEPTION_RECORD) exceptionRecord;
1050 mei.ThreadId = GetCurrentThreadId();
1051 mei.ExceptionPointers = &ep;
1052 pmei = &mei;
1053 } else {
1054 pmei = NULL;
1055 }
1058 // Older versions of dbghelp.dll (the one shipped with Win2003 for example) may not support all
1059 // the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then.
1060 if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false &&
1061 _MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) {
1062 DWORD error = GetLastError();
1063 LPTSTR msgbuf = NULL;
1065 if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1066 FORMAT_MESSAGE_FROM_SYSTEM |
1067 FORMAT_MESSAGE_IGNORE_INSERTS,
1068 NULL, error, 0, (LPTSTR)&msgbuf, 0, NULL) != 0) {
1070 jio_snprintf(buffer, bufferSize, "Call to MiniDumpWriteDump() failed (Error 0x%x: %s)", error, msgbuf);
1071 LocalFree(msgbuf);
1072 } else {
1073 // Call to FormatMessage failed, just include the result from GetLastError
1074 jio_snprintf(buffer, bufferSize, "Call to MiniDumpWriteDump() failed (Error 0x%x)", error);
1075 }
1076 VMError::report_coredump_status(buffer, false);
1077 } else {
1078 VMError::report_coredump_status(buffer, true);
1079 }
1081 CloseHandle(dumpFile);
1082 }
1086 void os::abort(bool dump_core)
1087 {
1088 os::shutdown();
1089 // no core dump on Windows
1090 ::exit(1);
1091 }
1093 // Die immediately, no exit hook, no abort hook, no cleanup.
1094 void os::die() {
1095 _exit(-1);
1096 }
1098 // Directory routines copied from src/win32/native/java/io/dirent_md.c
1099 // * dirent_md.c 1.15 00/02/02
1100 //
1101 // The declarations for DIR and struct dirent are in jvm_win32.h.
1103 /* Caller must have already run dirname through JVM_NativePath, which removes
1104 duplicate slashes and converts all instances of '/' into '\\'. */
1106 DIR *
1107 os::opendir(const char *dirname)
1108 {
1109 assert(dirname != NULL, "just checking"); // hotspot change
1110 DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal);
1111 DWORD fattr; // hotspot change
1112 char alt_dirname[4] = { 0, 0, 0, 0 };
1114 if (dirp == 0) {
1115 errno = ENOMEM;
1116 return 0;
1117 }
1119 /*
1120 * Win32 accepts "\" in its POSIX stat(), but refuses to treat it
1121 * as a directory in FindFirstFile(). We detect this case here and
1122 * prepend the current drive name.
1123 */
1124 if (dirname[1] == '\0' && dirname[0] == '\\') {
1125 alt_dirname[0] = _getdrive() + 'A' - 1;
1126 alt_dirname[1] = ':';
1127 alt_dirname[2] = '\\';
1128 alt_dirname[3] = '\0';
1129 dirname = alt_dirname;
1130 }
1132 dirp->path = (char *)malloc(strlen(dirname) + 5, mtInternal);
1133 if (dirp->path == 0) {
1134 free(dirp, mtInternal);
1135 errno = ENOMEM;
1136 return 0;
1137 }
1138 strcpy(dirp->path, dirname);
1140 fattr = GetFileAttributes(dirp->path);
1141 if (fattr == 0xffffffff) {
1142 free(dirp->path, mtInternal);
1143 free(dirp, mtInternal);
1144 errno = ENOENT;
1145 return 0;
1146 } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
1147 free(dirp->path, mtInternal);
1148 free(dirp, mtInternal);
1149 errno = ENOTDIR;
1150 return 0;
1151 }
1153 /* Append "*.*", or possibly "\\*.*", to path */
1154 if (dirp->path[1] == ':'
1155 && (dirp->path[2] == '\0'
1156 || (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
1157 /* No '\\' needed for cases like "Z:" or "Z:\" */
1158 strcat(dirp->path, "*.*");
1159 } else {
1160 strcat(dirp->path, "\\*.*");
1161 }
1163 dirp->handle = FindFirstFile(dirp->path, &dirp->find_data);
1164 if (dirp->handle == INVALID_HANDLE_VALUE) {
1165 if (GetLastError() != ERROR_FILE_NOT_FOUND) {
1166 free(dirp->path, mtInternal);
1167 free(dirp, mtInternal);
1168 errno = EACCES;
1169 return 0;
1170 }
1171 }
1172 return dirp;
1173 }
1175 struct dirent *
1176 os::readdir(DIR *dirp)
1177 {
1178 assert(dirp != NULL, "just checking"); // hotspot change
1179 if (dirp->handle == INVALID_HANDLE_VALUE) {
1180 return NULL;
1181 }
1183 strcpy(dirp->dirent.d_name, dirp->find_data.cFileName);
1185 if (!FindNextFile(dirp->handle, &dirp->find_data)) {
1186 if (GetLastError() == ERROR_INVALID_HANDLE) {
1187 errno = EBADF;
1188 return NULL;
1189 }
1190 FindClose(dirp->handle);
1191 dirp->handle = INVALID_HANDLE_VALUE;
1192 }
1194 return &dirp->dirent;
1195 }
1197 int
1198 os::closedir(DIR *dirp)
1199 {
1200 assert(dirp != NULL, "just checking"); // hotspot change
1201 if (dirp->handle != INVALID_HANDLE_VALUE) {
1202 if (!FindClose(dirp->handle)) {
1203 errno = EBADF;
1204 return -1;
1205 }
1206 dirp->handle = INVALID_HANDLE_VALUE;
1207 }
1208 free(dirp->path, mtInternal);
1209 free(dirp, mtInternal);
1210 return 0;
1211 }
1213 // This must be hard coded because it's the system's temporary
1214 // directory not the java application's temp directory, ala java.io.tmpdir.
1215 const char* os::get_temp_directory() {
1216 static char path_buf[MAX_PATH];
1217 if (GetTempPath(MAX_PATH, path_buf)>0)
1218 return path_buf;
1219 else{
1220 path_buf[0]='\0';
1221 return path_buf;
1222 }
1223 }
1225 static bool file_exists(const char* filename) {
1226 if (filename == NULL || strlen(filename) == 0) {
1227 return false;
1228 }
1229 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
1230 }
1232 bool os::dll_build_name(char *buffer, size_t buflen,
1233 const char* pname, const char* fname) {
1234 bool retval = false;
1235 const size_t pnamelen = pname ? strlen(pname) : 0;
1236 const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
1238 // Return error on buffer overflow.
1239 if (pnamelen + strlen(fname) + 10 > buflen) {
1240 return retval;
1241 }
1243 if (pnamelen == 0) {
1244 jio_snprintf(buffer, buflen, "%s.dll", fname);
1245 retval = true;
1246 } else if (c == ':' || c == '\\') {
1247 jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname);
1248 retval = true;
1249 } else if (strchr(pname, *os::path_separator()) != NULL) {
1250 int n;
1251 char** pelements = split_path(pname, &n);
1252 if (pelements == NULL) {
1253 return false;
1254 }
1255 for (int i = 0 ; i < n ; i++) {
1256 char* path = pelements[i];
1257 // Really shouldn't be NULL, but check can't hurt
1258 size_t plen = (path == NULL) ? 0 : strlen(path);
1259 if (plen == 0) {
1260 continue; // skip the empty path values
1261 }
1262 const char lastchar = path[plen - 1];
1263 if (lastchar == ':' || lastchar == '\\') {
1264 jio_snprintf(buffer, buflen, "%s%s.dll", path, fname);
1265 } else {
1266 jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname);
1267 }
1268 if (file_exists(buffer)) {
1269 retval = true;
1270 break;
1271 }
1272 }
1273 // release the storage
1274 for (int i = 0 ; i < n ; i++) {
1275 if (pelements[i] != NULL) {
1276 FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
1277 }
1278 }
1279 if (pelements != NULL) {
1280 FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
1281 }
1282 } else {
1283 jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname);
1284 retval = true;
1285 }
1286 return retval;
1287 }
1289 // Needs to be in os specific directory because windows requires another
1290 // header file <direct.h>
1291 const char* os::get_current_directory(char *buf, size_t buflen) {
1292 int n = static_cast<int>(buflen);
1293 if (buflen > INT_MAX) n = INT_MAX;
1294 return _getcwd(buf, n);
1295 }
1297 //-----------------------------------------------------------
1298 // Helper functions for fatal error handler
1299 #ifdef _WIN64
1300 // Helper routine which returns true if address in
1301 // within the NTDLL address space.
1302 //
1303 static bool _addr_in_ntdll( address addr )
1304 {
1305 HMODULE hmod;
1306 MODULEINFO minfo;
1308 hmod = GetModuleHandle("NTDLL.DLL");
1309 if ( hmod == NULL ) return false;
1310 if ( !os::PSApiDll::GetModuleInformation( GetCurrentProcess(), hmod,
1311 &minfo, sizeof(MODULEINFO)) )
1312 return false;
1314 if ( (addr >= minfo.lpBaseOfDll) &&
1315 (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage)))
1316 return true;
1317 else
1318 return false;
1319 }
1320 #endif
1323 // Enumerate all modules for a given process ID
1324 //
1325 // Notice that Windows 95/98/Me and Windows NT/2000/XP have
1326 // different API for doing this. We use PSAPI.DLL on NT based
1327 // Windows and ToolHelp on 95/98/Me.
1329 // Callback function that is called by enumerate_modules() on
1330 // every DLL module.
1331 // Input parameters:
1332 // int pid,
1333 // char* module_file_name,
1334 // address module_base_addr,
1335 // unsigned module_size,
1336 // void* param
1337 typedef int (*EnumModulesCallbackFunc)(int, char *, address, unsigned, void *);
1339 // enumerate_modules for Windows NT, using PSAPI
1340 static int _enumerate_modules_winnt( int pid, EnumModulesCallbackFunc func, void * param)
1341 {
1342 HANDLE hProcess ;
1344 # define MAX_NUM_MODULES 128
1345 HMODULE modules[MAX_NUM_MODULES];
1346 static char filename[ MAX_PATH ];
1347 int result = 0;
1349 if (!os::PSApiDll::PSApiAvailable()) {
1350 return 0;
1351 }
1353 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1354 FALSE, pid ) ;
1355 if (hProcess == NULL) return 0;
1357 DWORD size_needed;
1358 if (!os::PSApiDll::EnumProcessModules(hProcess, modules,
1359 sizeof(modules), &size_needed)) {
1360 CloseHandle( hProcess );
1361 return 0;
1362 }
1364 // number of modules that are currently loaded
1365 int num_modules = size_needed / sizeof(HMODULE);
1367 for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1368 // Get Full pathname:
1369 if(!os::PSApiDll::GetModuleFileNameEx(hProcess, modules[i],
1370 filename, sizeof(filename))) {
1371 filename[0] = '\0';
1372 }
1374 MODULEINFO modinfo;
1375 if (!os::PSApiDll::GetModuleInformation(hProcess, modules[i],
1376 &modinfo, sizeof(modinfo))) {
1377 modinfo.lpBaseOfDll = NULL;
1378 modinfo.SizeOfImage = 0;
1379 }
1381 // Invoke callback function
1382 result = func(pid, filename, (address)modinfo.lpBaseOfDll,
1383 modinfo.SizeOfImage, param);
1384 if (result) break;
1385 }
1387 CloseHandle( hProcess ) ;
1388 return result;
1389 }
1392 // enumerate_modules for Windows 95/98/ME, using TOOLHELP
1393 static int _enumerate_modules_windows( int pid, EnumModulesCallbackFunc func, void *param)
1394 {
1395 HANDLE hSnapShot ;
1396 static MODULEENTRY32 modentry ;
1397 int result = 0;
1399 if (!os::Kernel32Dll::HelpToolsAvailable()) {
1400 return 0;
1401 }
1403 // Get a handle to a Toolhelp snapshot of the system
1404 hSnapShot = os::Kernel32Dll::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pid ) ;
1405 if( hSnapShot == INVALID_HANDLE_VALUE ) {
1406 return FALSE ;
1407 }
1409 // iterate through all modules
1410 modentry.dwSize = sizeof(MODULEENTRY32) ;
1411 bool not_done = os::Kernel32Dll::Module32First( hSnapShot, &modentry ) != 0;
1413 while( not_done ) {
1414 // invoke the callback
1415 result=func(pid, modentry.szExePath, (address)modentry.modBaseAddr,
1416 modentry.modBaseSize, param);
1417 if (result) break;
1419 modentry.dwSize = sizeof(MODULEENTRY32) ;
1420 not_done = os::Kernel32Dll::Module32Next( hSnapShot, &modentry ) != 0;
1421 }
1423 CloseHandle(hSnapShot);
1424 return result;
1425 }
1427 int enumerate_modules( int pid, EnumModulesCallbackFunc func, void * param )
1428 {
1429 // Get current process ID if caller doesn't provide it.
1430 if (!pid) pid = os::current_process_id();
1432 if (os::win32::is_nt()) return _enumerate_modules_winnt (pid, func, param);
1433 else return _enumerate_modules_windows(pid, func, param);
1434 }
1436 struct _modinfo {
1437 address addr;
1438 char* full_path; // point to a char buffer
1439 int buflen; // size of the buffer
1440 address base_addr;
1441 };
1443 static int _locate_module_by_addr(int pid, char * mod_fname, address base_addr,
1444 unsigned size, void * param) {
1445 struct _modinfo *pmod = (struct _modinfo *)param;
1446 if (!pmod) return -1;
1448 if (base_addr <= pmod->addr &&
1449 base_addr+size > pmod->addr) {
1450 // if a buffer is provided, copy path name to the buffer
1451 if (pmod->full_path) {
1452 jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
1453 }
1454 pmod->base_addr = base_addr;
1455 return 1;
1456 }
1457 return 0;
1458 }
1460 bool os::dll_address_to_library_name(address addr, char* buf,
1461 int buflen, int* offset) {
1462 // buf is not optional, but offset is optional
1463 assert(buf != NULL, "sanity check");
1465 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
1466 // return the full path to the DLL file, sometimes it returns path
1467 // to the corresponding PDB file (debug info); sometimes it only
1468 // returns partial path, which makes life painful.
1470 struct _modinfo mi;
1471 mi.addr = addr;
1472 mi.full_path = buf;
1473 mi.buflen = buflen;
1474 int pid = os::current_process_id();
1475 if (enumerate_modules(pid, _locate_module_by_addr, (void *)&mi)) {
1476 // buf already contains path name
1477 if (offset) *offset = addr - mi.base_addr;
1478 return true;
1479 }
1481 buf[0] = '\0';
1482 if (offset) *offset = -1;
1483 return false;
1484 }
1486 bool os::dll_address_to_function_name(address addr, char *buf,
1487 int buflen, int *offset) {
1488 // buf is not optional, but offset is optional
1489 assert(buf != NULL, "sanity check");
1491 if (Decoder::decode(addr, buf, buflen, offset)) {
1492 return true;
1493 }
1494 if (offset != NULL) *offset = -1;
1495 buf[0] = '\0';
1496 return false;
1497 }
1499 // save the start and end address of jvm.dll into param[0] and param[1]
1500 static int _locate_jvm_dll(int pid, char* mod_fname, address base_addr,
1501 unsigned size, void * param) {
1502 if (!param) return -1;
1504 if (base_addr <= (address)_locate_jvm_dll &&
1505 base_addr+size > (address)_locate_jvm_dll) {
1506 ((address*)param)[0] = base_addr;
1507 ((address*)param)[1] = base_addr + size;
1508 return 1;
1509 }
1510 return 0;
1511 }
1513 address vm_lib_location[2]; // start and end address of jvm.dll
1515 // check if addr is inside jvm.dll
1516 bool os::address_is_in_vm(address addr) {
1517 if (!vm_lib_location[0] || !vm_lib_location[1]) {
1518 int pid = os::current_process_id();
1519 if (!enumerate_modules(pid, _locate_jvm_dll, (void *)vm_lib_location)) {
1520 assert(false, "Can't find jvm module.");
1521 return false;
1522 }
1523 }
1525 return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]);
1526 }
1528 // print module info; param is outputStream*
1529 static int _print_module(int pid, char* fname, address base,
1530 unsigned size, void* param) {
1531 if (!param) return -1;
1533 outputStream* st = (outputStream*)param;
1535 address end_addr = base + size;
1536 st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base, end_addr, fname);
1537 return 0;
1538 }
1540 // Loads .dll/.so and
1541 // in case of error it checks if .dll/.so was built for the
1542 // same architecture as Hotspot is running on
1543 void * os::dll_load(const char *name, char *ebuf, int ebuflen)
1544 {
1545 void * result = LoadLibrary(name);
1546 if (result != NULL)
1547 {
1548 return result;
1549 }
1551 DWORD errcode = GetLastError();
1552 if (errcode == ERROR_MOD_NOT_FOUND) {
1553 strncpy(ebuf, "Can't find dependent libraries", ebuflen-1);
1554 ebuf[ebuflen-1]='\0';
1555 return NULL;
1556 }
1558 // Parsing dll below
1559 // If we can read dll-info and find that dll was built
1560 // for an architecture other than Hotspot is running in
1561 // - then print to buffer "DLL was built for a different architecture"
1562 // else call os::lasterror to obtain system error message
1564 // Read system error message into ebuf
1565 // It may or may not be overwritten below (in the for loop and just above)
1566 lasterror(ebuf, (size_t) ebuflen);
1567 ebuf[ebuflen-1]='\0';
1568 int file_descriptor=::open(name, O_RDONLY | O_BINARY, 0);
1569 if (file_descriptor<0)
1570 {
1571 return NULL;
1572 }
1574 uint32_t signature_offset;
1575 uint16_t lib_arch=0;
1576 bool failed_to_get_lib_arch=
1577 (
1578 //Go to position 3c in the dll
1579 (os::seek_to_file_offset(file_descriptor,IMAGE_FILE_PTR_TO_SIGNATURE)<0)
1580 ||
1581 // Read loacation of signature
1582 (sizeof(signature_offset)!=
1583 (os::read(file_descriptor, (void*)&signature_offset,sizeof(signature_offset))))
1584 ||
1585 //Go to COFF File Header in dll
1586 //that is located after"signature" (4 bytes long)
1587 (os::seek_to_file_offset(file_descriptor,
1588 signature_offset+IMAGE_FILE_SIGNATURE_LENGTH)<0)
1589 ||
1590 //Read field that contains code of architecture
1591 // that dll was build for
1592 (sizeof(lib_arch)!=
1593 (os::read(file_descriptor, (void*)&lib_arch,sizeof(lib_arch))))
1594 );
1596 ::close(file_descriptor);
1597 if (failed_to_get_lib_arch)
1598 {
1599 // file i/o error - report os::lasterror(...) msg
1600 return NULL;
1601 }
1603 typedef struct
1604 {
1605 uint16_t arch_code;
1606 char* arch_name;
1607 } arch_t;
1609 static const arch_t arch_array[]={
1610 {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"},
1611 {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"},
1612 {IMAGE_FILE_MACHINE_IA64, (char*)"IA 64"}
1613 };
1614 #if (defined _M_IA64)
1615 static const uint16_t running_arch=IMAGE_FILE_MACHINE_IA64;
1616 #elif (defined _M_AMD64)
1617 static const uint16_t running_arch=IMAGE_FILE_MACHINE_AMD64;
1618 #elif (defined _M_IX86)
1619 static const uint16_t running_arch=IMAGE_FILE_MACHINE_I386;
1620 #else
1621 #error Method os::dll_load requires that one of following \
1622 is defined :_M_IA64,_M_AMD64 or _M_IX86
1623 #endif
1626 // Obtain a string for printf operation
1627 // lib_arch_str shall contain string what platform this .dll was built for
1628 // running_arch_str shall string contain what platform Hotspot was built for
1629 char *running_arch_str=NULL,*lib_arch_str=NULL;
1630 for (unsigned int i=0;i<ARRAY_SIZE(arch_array);i++)
1631 {
1632 if (lib_arch==arch_array[i].arch_code)
1633 lib_arch_str=arch_array[i].arch_name;
1634 if (running_arch==arch_array[i].arch_code)
1635 running_arch_str=arch_array[i].arch_name;
1636 }
1638 assert(running_arch_str,
1639 "Didn't find runing architecture code in arch_array");
1641 // If the architure is right
1642 // but some other error took place - report os::lasterror(...) msg
1643 if (lib_arch == running_arch)
1644 {
1645 return NULL;
1646 }
1648 if (lib_arch_str!=NULL)
1649 {
1650 ::_snprintf(ebuf, ebuflen-1,
1651 "Can't load %s-bit .dll on a %s-bit platform",
1652 lib_arch_str,running_arch_str);
1653 }
1654 else
1655 {
1656 // don't know what architecture this dll was build for
1657 ::_snprintf(ebuf, ebuflen-1,
1658 "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
1659 lib_arch,running_arch_str);
1660 }
1662 return NULL;
1663 }
1666 void os::print_dll_info(outputStream *st) {
1667 int pid = os::current_process_id();
1668 st->print_cr("Dynamic libraries:");
1669 enumerate_modules(pid, _print_module, (void *)st);
1670 }
1672 void os::print_os_info_brief(outputStream* st) {
1673 os::print_os_info(st);
1674 }
1676 void os::print_os_info(outputStream* st) {
1677 st->print("OS:");
1679 os::win32::print_windows_version(st);
1680 }
1682 void os::win32::print_windows_version(outputStream* st) {
1683 OSVERSIONINFOEX osvi;
1684 VS_FIXEDFILEINFO *file_info;
1685 TCHAR kernel32_path[MAX_PATH];
1686 UINT len, ret;
1688 // Use the GetVersionEx information to see if we're on a server or
1689 // workstation edition of Windows. Starting with Windows 8.1 we can't
1690 // trust the OS version information returned by this API.
1691 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1692 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1693 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1694 st->print_cr("Call to GetVersionEx failed");
1695 return;
1696 }
1697 bool is_workstation = (osvi.wProductType == VER_NT_WORKSTATION);
1699 // Get the full path to \Windows\System32\kernel32.dll and use that for
1700 // determining what version of Windows we're running on.
1701 len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1;
1702 ret = GetSystemDirectory(kernel32_path, len);
1703 if (ret == 0 || ret > len) {
1704 st->print_cr("Call to GetSystemDirectory failed");
1705 return;
1706 }
1707 strncat(kernel32_path, "\\kernel32.dll", MAX_PATH - ret);
1709 DWORD version_size = GetFileVersionInfoSize(kernel32_path, NULL);
1710 if (version_size == 0) {
1711 st->print_cr("Call to GetFileVersionInfoSize failed");
1712 return;
1713 }
1715 LPTSTR version_info = (LPTSTR)os::malloc(version_size, mtInternal);
1716 if (version_info == NULL) {
1717 st->print_cr("Failed to allocate version_info");
1718 return;
1719 }
1721 if (!GetFileVersionInfo(kernel32_path, NULL, version_size, version_info)) {
1722 os::free(version_info);
1723 st->print_cr("Call to GetFileVersionInfo failed");
1724 return;
1725 }
1727 if (!VerQueryValue(version_info, TEXT("\\"), (LPVOID*)&file_info, &len)) {
1728 os::free(version_info);
1729 st->print_cr("Call to VerQueryValue failed");
1730 return;
1731 }
1733 int major_version = HIWORD(file_info->dwProductVersionMS);
1734 int minor_version = LOWORD(file_info->dwProductVersionMS);
1735 int build_number = HIWORD(file_info->dwProductVersionLS);
1736 int build_minor = LOWORD(file_info->dwProductVersionLS);
1737 int os_vers = major_version * 1000 + minor_version;
1738 os::free(version_info);
1740 st->print(" Windows ");
1741 switch (os_vers) {
1743 case 6000:
1744 if (is_workstation) {
1745 st->print("Vista");
1746 } else {
1747 st->print("Server 2008");
1748 }
1749 break;
1751 case 6001:
1752 if (is_workstation) {
1753 st->print("7");
1754 } else {
1755 st->print("Server 2008 R2");
1756 }
1757 break;
1759 case 6002:
1760 if (is_workstation) {
1761 st->print("8");
1762 } else {
1763 st->print("Server 2012");
1764 }
1765 break;
1767 case 6003:
1768 if (is_workstation) {
1769 st->print("8.1");
1770 } else {
1771 st->print("Server 2012 R2");
1772 }
1773 break;
1775 case 6004:
1776 if (is_workstation) {
1777 st->print("10");
1778 } else {
1779 // distinguish Windows Server 2016 and 2019 by build number
1780 // Windows server 2019 GA 10/2018 build number is 17763
1781 if (build_number > 17762) {
1782 st->print("Server 2019");
1783 } else {
1784 st->print("Server 2016");
1785 }
1786 }
1787 break;
1789 default:
1790 // Unrecognized windows, print out its major and minor versions
1791 st->print("%d.%d", major_version, minor_version);
1792 break;
1793 }
1795 // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1796 // find out whether we are running on 64 bit processor or not
1797 SYSTEM_INFO si;
1798 ZeroMemory(&si, sizeof(SYSTEM_INFO));
1799 os::Kernel32Dll::GetNativeSystemInfo(&si);
1800 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
1801 st->print(" , 64 bit");
1802 }
1804 st->print(" Build %d", build_number);
1805 st->print(" (%d.%d.%d.%d)", major_version, minor_version, build_number, build_minor);
1806 st->cr();
1807 }
1809 void os::pd_print_cpu_info(outputStream* st) {
1810 // Nothing to do for now.
1811 }
1813 void os::print_memory_info(outputStream* st) {
1814 st->print("Memory:");
1815 st->print(" %dk page", os::vm_page_size()>>10);
1817 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1818 // value if total memory is larger than 4GB
1819 MEMORYSTATUSEX ms;
1820 ms.dwLength = sizeof(ms);
1821 GlobalMemoryStatusEx(&ms);
1823 st->print(", physical %uk", os::physical_memory() >> 10);
1824 st->print("(%uk free)", os::available_memory() >> 10);
1826 st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1827 st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1828 st->cr();
1829 }
1831 void os::print_siginfo(outputStream *st, void *siginfo) {
1832 EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo;
1833 st->print("siginfo:");
1834 st->print(" ExceptionCode=0x%x", er->ExceptionCode);
1836 if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1837 er->NumberParameters >= 2) {
1838 switch (er->ExceptionInformation[0]) {
1839 case 0: st->print(", reading address"); break;
1840 case 1: st->print(", writing address"); break;
1841 default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1842 er->ExceptionInformation[0]);
1843 }
1844 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1845 } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
1846 er->NumberParameters >= 2 && UseSharedSpaces) {
1847 FileMapInfo* mapinfo = FileMapInfo::current_info();
1848 if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) {
1849 st->print("\n\nError accessing class data sharing archive." \
1850 " Mapped file inaccessible during execution, " \
1851 " possible disk/network problem.");
1852 }
1853 } else {
1854 int num = er->NumberParameters;
1855 if (num > 0) {
1856 st->print(", ExceptionInformation=");
1857 for (int i = 0; i < num; i++) {
1858 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1859 }
1860 }
1861 }
1862 st->cr();
1863 }
1866 int os::vsnprintf(char* buf, size_t len, const char* fmt, va_list args) {
1867 #if _MSC_VER >= 1900
1868 // Starting with Visual Studio 2015, vsnprint is C99 compliant.
1869 int result = ::vsnprintf(buf, len, fmt, args);
1870 // If an encoding error occurred (result < 0) then it's not clear
1871 // whether the buffer is NUL terminated, so ensure it is.
1872 if ((result < 0) && (len > 0)) {
1873 buf[len - 1] = '\0';
1874 }
1875 return result;
1876 #else
1877 // Before Visual Studio 2015, vsnprintf is not C99 compliant, so use
1878 // _vsnprintf, whose behavior seems to be *mostly* consistent across
1879 // versions. However, when len == 0, avoid _vsnprintf too, and just
1880 // go straight to _vscprintf. The output is going to be truncated in
1881 // that case, except in the unusual case of empty output. More
1882 // importantly, the documentation for various versions of Visual Studio
1883 // are inconsistent about the behavior of _vsnprintf when len == 0,
1884 // including it possibly being an error.
1885 int result = -1;
1886 if (len > 0) {
1887 result = _vsnprintf(buf, len, fmt, args);
1888 // If output (including NUL terminator) is truncated, the buffer
1889 // won't be NUL terminated. Add the trailing NUL specified by C99.
1890 if ((result < 0) || (result >= (int) len)) {
1891 buf[len - 1] = '\0';
1892 }
1893 }
1894 if (result < 0) {
1895 result = _vscprintf(fmt, args);
1896 }
1897 return result;
1898 #endif // _MSC_VER dispatch
1899 }
1901 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1902 // do nothing
1903 }
1905 static char saved_jvm_path[MAX_PATH] = {0};
1907 // Find the full path to the current module, jvm.dll
1908 void os::jvm_path(char *buf, jint buflen) {
1909 // Error checking.
1910 if (buflen < MAX_PATH) {
1911 assert(false, "must use a large-enough buffer");
1912 buf[0] = '\0';
1913 return;
1914 }
1915 // Lazy resolve the path to current module.
1916 if (saved_jvm_path[0] != 0) {
1917 strcpy(buf, saved_jvm_path);
1918 return;
1919 }
1921 buf[0] = '\0';
1922 if (Arguments::created_by_gamma_launcher()) {
1923 // Support for the gamma launcher. Check for an
1924 // JAVA_HOME environment variable
1925 // and fix up the path so it looks like
1926 // libjvm.so is installed there (append a fake suffix
1927 // hotspot/libjvm.so).
1928 char* java_home_var = ::getenv("JAVA_HOME");
1929 if (java_home_var != NULL && java_home_var[0] != 0 &&
1930 strlen(java_home_var) < (size_t)buflen) {
1932 strncpy(buf, java_home_var, buflen);
1934 // determine if this is a legacy image or modules image
1935 // modules image doesn't have "jre" subdirectory
1936 size_t len = strlen(buf);
1937 char* jrebin_p = buf + len;
1938 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1939 if (0 != _access(buf, 0)) {
1940 jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1941 }
1942 len = strlen(buf);
1943 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1944 }
1945 }
1947 if(buf[0] == '\0') {
1948 GetModuleFileName(vm_lib_handle, buf, buflen);
1949 }
1950 strncpy(saved_jvm_path, buf, MAX_PATH);
1951 }
1954 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1955 #ifndef _WIN64
1956 st->print("_");
1957 #endif
1958 }
1961 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1962 #ifndef _WIN64
1963 st->print("@%d", args_size * sizeof(int));
1964 #endif
1965 }
1967 // This method is a copy of JDK's sysGetLastErrorString
1968 // from src/windows/hpi/src/system_md.c
1970 size_t os::lasterror(char* buf, size_t len) {
1971 DWORD errval;
1973 if ((errval = GetLastError()) != 0) {
1974 // DOS error
1975 size_t n = (size_t)FormatMessage(
1976 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1977 NULL,
1978 errval,
1979 0,
1980 buf,
1981 (DWORD)len,
1982 NULL);
1983 if (n > 3) {
1984 // Drop final '.', CR, LF
1985 if (buf[n - 1] == '\n') n--;
1986 if (buf[n - 1] == '\r') n--;
1987 if (buf[n - 1] == '.') n--;
1988 buf[n] = '\0';
1989 }
1990 return n;
1991 }
1993 if (errno != 0) {
1994 // C runtime error that has no corresponding DOS error code
1995 const char* s = strerror(errno);
1996 size_t n = strlen(s);
1997 if (n >= len) n = len - 1;
1998 strncpy(buf, s, n);
1999 buf[n] = '\0';
2000 return n;
2001 }
2003 return 0;
2004 }
2006 int os::get_last_error() {
2007 DWORD error = GetLastError();
2008 if (error == 0)
2009 error = errno;
2010 return (int)error;
2011 }
2013 // sun.misc.Signal
2014 // NOTE that this is a workaround for an apparent kernel bug where if
2015 // a signal handler for SIGBREAK is installed then that signal handler
2016 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
2017 // See bug 4416763.
2018 static void (*sigbreakHandler)(int) = NULL;
2020 static void UserHandler(int sig, void *siginfo, void *context) {
2021 os::signal_notify(sig);
2022 // We need to reinstate the signal handler each time...
2023 os::signal(sig, (void*)UserHandler);
2024 }
2026 void* os::user_handler() {
2027 return (void*) UserHandler;
2028 }
2030 void* os::signal(int signal_number, void* handler) {
2031 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
2032 void (*oldHandler)(int) = sigbreakHandler;
2033 sigbreakHandler = (void (*)(int)) handler;
2034 return (void*) oldHandler;
2035 } else {
2036 return (void*)::signal(signal_number, (void (*)(int))handler);
2037 }
2038 }
2040 void os::signal_raise(int signal_number) {
2041 raise(signal_number);
2042 }
2044 // The Win32 C runtime library maps all console control events other than ^C
2045 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
2046 // logoff, and shutdown events. We therefore install our own console handler
2047 // that raises SIGTERM for the latter cases.
2048 //
2049 static BOOL WINAPI consoleHandler(DWORD event) {
2050 switch(event) {
2051 case CTRL_C_EVENT:
2052 if (is_error_reported()) {
2053 // Ctrl-C is pressed during error reporting, likely because the error
2054 // handler fails to abort. Let VM die immediately.
2055 os::die();
2056 }
2058 os::signal_raise(SIGINT);
2059 return TRUE;
2060 break;
2061 case CTRL_BREAK_EVENT:
2062 if (sigbreakHandler != NULL) {
2063 (*sigbreakHandler)(SIGBREAK);
2064 }
2065 return TRUE;
2066 break;
2067 case CTRL_LOGOFF_EVENT: {
2068 // Don't terminate JVM if it is running in a non-interactive session,
2069 // such as a service process.
2070 USEROBJECTFLAGS flags;
2071 HANDLE handle = GetProcessWindowStation();
2072 if (handle != NULL &&
2073 GetUserObjectInformation(handle, UOI_FLAGS, &flags,
2074 sizeof( USEROBJECTFLAGS), NULL)) {
2075 // If it is a non-interactive session, let next handler to deal
2076 // with it.
2077 if ((flags.dwFlags & WSF_VISIBLE) == 0) {
2078 return FALSE;
2079 }
2080 }
2081 }
2082 case CTRL_CLOSE_EVENT:
2083 case CTRL_SHUTDOWN_EVENT:
2084 os::signal_raise(SIGTERM);
2085 return TRUE;
2086 break;
2087 default:
2088 break;
2089 }
2090 return FALSE;
2091 }
2093 /*
2094 * The following code is moved from os.cpp for making this
2095 * code platform specific, which it is by its very nature.
2096 */
2098 // Return maximum OS signal used + 1 for internal use only
2099 // Used as exit signal for signal_thread
2100 int os::sigexitnum_pd(){
2101 return NSIG;
2102 }
2104 // a counter for each possible signal value, including signal_thread exit signal
2105 static volatile jint pending_signals[NSIG+1] = { 0 };
2106 static HANDLE sig_sem = NULL;
2108 void os::signal_init_pd() {
2109 // Initialize signal structures
2110 memset((void*)pending_signals, 0, sizeof(pending_signals));
2112 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
2114 // Programs embedding the VM do not want it to attempt to receive
2115 // events like CTRL_LOGOFF_EVENT, which are used to implement the
2116 // shutdown hooks mechanism introduced in 1.3. For example, when
2117 // the VM is run as part of a Windows NT service (i.e., a servlet
2118 // engine in a web server), the correct behavior is for any console
2119 // control handler to return FALSE, not TRUE, because the OS's
2120 // "final" handler for such events allows the process to continue if
2121 // it is a service (while terminating it if it is not a service).
2122 // To make this behavior uniform and the mechanism simpler, we
2123 // completely disable the VM's usage of these console events if -Xrs
2124 // (=ReduceSignalUsage) is specified. This means, for example, that
2125 // the CTRL-BREAK thread dump mechanism is also disabled in this
2126 // case. See bugs 4323062, 4345157, and related bugs.
2128 if (!ReduceSignalUsage) {
2129 // Add a CTRL-C handler
2130 SetConsoleCtrlHandler(consoleHandler, TRUE);
2131 }
2132 }
2134 void os::signal_notify(int signal_number) {
2135 BOOL ret;
2136 if (sig_sem != NULL) {
2137 Atomic::inc(&pending_signals[signal_number]);
2138 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2139 assert(ret != 0, "ReleaseSemaphore() failed");
2140 }
2141 }
2143 static int check_pending_signals(bool wait_for_signal) {
2144 DWORD ret;
2145 while (true) {
2146 for (int i = 0; i < NSIG + 1; i++) {
2147 jint n = pending_signals[i];
2148 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2149 return i;
2150 }
2151 }
2152 if (!wait_for_signal) {
2153 return -1;
2154 }
2156 JavaThread *thread = JavaThread::current();
2158 ThreadBlockInVM tbivm(thread);
2160 bool threadIsSuspended;
2161 do {
2162 thread->set_suspend_equivalent();
2163 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2164 ret = ::WaitForSingleObject(sig_sem, INFINITE);
2165 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
2167 // were we externally suspended while we were waiting?
2168 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2169 if (threadIsSuspended) {
2170 //
2171 // The semaphore has been incremented, but while we were waiting
2172 // another thread suspended us. We don't want to continue running
2173 // while suspended because that would surprise the thread that
2174 // suspended us.
2175 //
2176 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2177 assert(ret != 0, "ReleaseSemaphore() failed");
2179 thread->java_suspend_self();
2180 }
2181 } while (threadIsSuspended);
2182 }
2183 }
2185 int os::signal_lookup() {
2186 return check_pending_signals(false);
2187 }
2189 int os::signal_wait() {
2190 return check_pending_signals(true);
2191 }
2193 // Implicit OS exception handling
2195 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
2196 JavaThread* thread = JavaThread::current();
2197 // Save pc in thread
2198 #ifdef _M_IA64
2199 // Do not blow up if no thread info available.
2200 if (thread) {
2201 // Saving PRECISE pc (with slot information) in thread.
2202 uint64_t precise_pc = (uint64_t) exceptionInfo->ExceptionRecord->ExceptionAddress;
2203 // Convert precise PC into "Unix" format
2204 precise_pc = (precise_pc & 0xFFFFFFFFFFFFFFF0) | ((precise_pc & 0xF) >> 2);
2205 thread->set_saved_exception_pc((address)precise_pc);
2206 }
2207 // Set pc to handler
2208 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
2209 // Clear out psr.ri (= Restart Instruction) in order to continue
2210 // at the beginning of the target bundle.
2211 exceptionInfo->ContextRecord->StIPSR &= 0xFFFFF9FFFFFFFFFF;
2212 assert(((DWORD64)handler & 0xF) == 0, "Target address must point to the beginning of a bundle!");
2213 #else
2214 #ifdef _M_AMD64
2215 // Do not blow up if no thread info available.
2216 if (thread) {
2217 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Rip);
2218 }
2219 // Set pc to handler
2220 exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
2221 #else
2222 // Do not blow up if no thread info available.
2223 if (thread) {
2224 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Eip);
2225 }
2226 // Set pc to handler
2227 exceptionInfo->ContextRecord->Eip = (DWORD)(DWORD_PTR)handler;
2228 #endif
2229 #endif
2231 // Continue the execution
2232 return EXCEPTION_CONTINUE_EXECUTION;
2233 }
2236 // Used for PostMortemDump
2237 extern "C" void safepoints();
2238 extern "C" void find(int x);
2239 extern "C" void events();
2241 // According to Windows API documentation, an illegal instruction sequence should generate
2242 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2243 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2244 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2246 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2248 // From "Execution Protection in the Windows Operating System" draft 0.35
2249 // Once a system header becomes available, the "real" define should be
2250 // included or copied here.
2251 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2253 // Handle NAT Bit consumption on IA64.
2254 #ifdef _M_IA64
2255 #define EXCEPTION_REG_NAT_CONSUMPTION STATUS_REG_NAT_CONSUMPTION
2256 #endif
2258 // Windows Vista/2008 heap corruption check
2259 #define EXCEPTION_HEAP_CORRUPTION 0xC0000374
2261 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2262 // C++ compiler contain this error code. Because this is a compiler-generated
2263 // error, the code is not listed in the Win32 API header files.
2264 // The code is actually a cryptic mnemonic device, with the initial "E"
2265 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2266 // ASCII values of "msc".
2268 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363
2270 #define def_excpt(val) { #val, (val) }
2272 static const struct { char* name; uint number; } exceptlabels[] = {
2273 def_excpt(EXCEPTION_ACCESS_VIOLATION),
2274 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2275 def_excpt(EXCEPTION_BREAKPOINT),
2276 def_excpt(EXCEPTION_SINGLE_STEP),
2277 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2278 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2279 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2280 def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2281 def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2282 def_excpt(EXCEPTION_FLT_OVERFLOW),
2283 def_excpt(EXCEPTION_FLT_STACK_CHECK),
2284 def_excpt(EXCEPTION_FLT_UNDERFLOW),
2285 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2286 def_excpt(EXCEPTION_INT_OVERFLOW),
2287 def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2288 def_excpt(EXCEPTION_IN_PAGE_ERROR),
2289 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2290 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2291 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2292 def_excpt(EXCEPTION_STACK_OVERFLOW),
2293 def_excpt(EXCEPTION_INVALID_DISPOSITION),
2294 def_excpt(EXCEPTION_GUARD_PAGE),
2295 def_excpt(EXCEPTION_INVALID_HANDLE),
2296 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2297 def_excpt(EXCEPTION_HEAP_CORRUPTION)
2298 #ifdef _M_IA64
2299 , def_excpt(EXCEPTION_REG_NAT_CONSUMPTION)
2300 #endif
2301 };
2303 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2304 uint code = static_cast<uint>(exception_code);
2305 for (uint i = 0; i < ARRAY_SIZE(exceptlabels); ++i) {
2306 if (exceptlabels[i].number == code) {
2307 jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2308 return buf;
2309 }
2310 }
2312 return NULL;
2313 }
2315 //-----------------------------------------------------------------------------
2316 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2317 // handle exception caused by idiv; should only happen for -MinInt/-1
2318 // (division by zero is handled explicitly)
2319 #ifdef _M_IA64
2320 assert(0, "Fix Handle_IDiv_Exception");
2321 #else
2322 #ifdef _M_AMD64
2323 PCONTEXT ctx = exceptionInfo->ContextRecord;
2324 address pc = (address)ctx->Rip;
2325 assert(pc[0] == 0xF7, "not an idiv opcode");
2326 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2327 assert(ctx->Rax == min_jint, "unexpected idiv exception");
2328 // set correct result values and continue after idiv instruction
2329 ctx->Rip = (DWORD64)pc + 2; // idiv reg, reg is 2 bytes
2330 ctx->Rax = (DWORD64)min_jint; // result
2331 ctx->Rdx = (DWORD64)0; // remainder
2332 // Continue the execution
2333 #else
2334 PCONTEXT ctx = exceptionInfo->ContextRecord;
2335 address pc = (address)ctx->Eip;
2336 assert(pc[0] == 0xF7, "not an idiv opcode");
2337 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2338 assert(ctx->Eax == min_jint, "unexpected idiv exception");
2339 // set correct result values and continue after idiv instruction
2340 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2341 ctx->Eax = (DWORD)min_jint; // result
2342 ctx->Edx = (DWORD)0; // remainder
2343 // Continue the execution
2344 #endif
2345 #endif
2346 return EXCEPTION_CONTINUE_EXECUTION;
2347 }
2349 #ifndef _WIN64
2350 //-----------------------------------------------------------------------------
2351 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2352 // handle exception caused by native method modifying control word
2353 PCONTEXT ctx = exceptionInfo->ContextRecord;
2354 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2356 switch (exception_code) {
2357 case EXCEPTION_FLT_DENORMAL_OPERAND:
2358 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2359 case EXCEPTION_FLT_INEXACT_RESULT:
2360 case EXCEPTION_FLT_INVALID_OPERATION:
2361 case EXCEPTION_FLT_OVERFLOW:
2362 case EXCEPTION_FLT_STACK_CHECK:
2363 case EXCEPTION_FLT_UNDERFLOW:
2364 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2365 if (fp_control_word != ctx->FloatSave.ControlWord) {
2366 // Restore FPCW and mask out FLT exceptions
2367 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2368 // Mask out pending FLT exceptions
2369 ctx->FloatSave.StatusWord &= 0xffffff00;
2370 return EXCEPTION_CONTINUE_EXECUTION;
2371 }
2372 }
2374 if (prev_uef_handler != NULL) {
2375 // We didn't handle this exception so pass it to the previous
2376 // UnhandledExceptionFilter.
2377 return (prev_uef_handler)(exceptionInfo);
2378 }
2380 return EXCEPTION_CONTINUE_SEARCH;
2381 }
2382 #else //_WIN64
2383 /*
2384 On Windows, the mxcsr control bits are non-volatile across calls
2385 See also CR 6192333
2386 If EXCEPTION_FLT_* happened after some native method modified
2387 mxcsr - it is not a jvm fault.
2388 However should we decide to restore of mxcsr after a faulty
2389 native method we can uncomment following code
2390 jint MxCsr = INITIAL_MXCSR;
2391 // we can't use StubRoutines::addr_mxcsr_std()
2392 // because in Win64 mxcsr is not saved there
2393 if (MxCsr != ctx->MxCsr) {
2394 ctx->MxCsr = MxCsr;
2395 return EXCEPTION_CONTINUE_EXECUTION;
2396 }
2398 */
2399 #endif // _WIN64
2402 static inline void report_error(Thread* t, DWORD exception_code,
2403 address addr, void* siginfo, void* context) {
2404 VMError err(t, exception_code, addr, siginfo, context);
2405 err.report_and_die();
2407 // If UseOsErrorReporting, this will return here and save the error file
2408 // somewhere where we can find it in the minidump.
2409 }
2411 //-----------------------------------------------------------------------------
2412 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2413 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2414 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2415 #ifdef _M_IA64
2416 // On Itanium, we need the "precise pc", which has the slot number coded
2417 // into the least 4 bits: 0000=slot0, 0100=slot1, 1000=slot2 (Windows format).
2418 address pc = (address) exceptionInfo->ExceptionRecord->ExceptionAddress;
2419 // Convert the pc to "Unix format", which has the slot number coded
2420 // into the least 2 bits: 0000=slot0, 0001=slot1, 0010=slot2
2421 // This is needed for IA64 because "relocation" / "implicit null check" / "poll instruction"
2422 // information is saved in the Unix format.
2423 address pc_unix_format = (address) ((((uint64_t)pc) & 0xFFFFFFFFFFFFFFF0) | ((((uint64_t)pc) & 0xF) >> 2));
2424 #else
2425 #ifdef _M_AMD64
2426 address pc = (address) exceptionInfo->ContextRecord->Rip;
2427 #else
2428 address pc = (address) exceptionInfo->ContextRecord->Eip;
2429 #endif
2430 #endif
2431 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady
2433 // Handle SafeFetch32 and SafeFetchN exceptions.
2434 if (StubRoutines::is_safefetch_fault(pc)) {
2435 return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc));
2436 }
2438 #ifndef _WIN64
2439 // Execution protection violation - win32 running on AMD64 only
2440 // Handled first to avoid misdiagnosis as a "normal" access violation;
2441 // This is safe to do because we have a new/unique ExceptionInformation
2442 // code for this condition.
2443 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2444 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2445 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2446 address addr = (address) exceptionRecord->ExceptionInformation[1];
2448 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2449 int page_size = os::vm_page_size();
2451 // Make sure the pc and the faulting address are sane.
2452 //
2453 // If an instruction spans a page boundary, and the page containing
2454 // the beginning of the instruction is executable but the following
2455 // page is not, the pc and the faulting address might be slightly
2456 // different - we still want to unguard the 2nd page in this case.
2457 //
2458 // 15 bytes seems to be a (very) safe value for max instruction size.
2459 bool pc_is_near_addr =
2460 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2461 bool instr_spans_page_boundary =
2462 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2463 (intptr_t) page_size) > 0);
2465 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2466 static volatile address last_addr =
2467 (address) os::non_memory_address_word();
2469 // In conservative mode, don't unguard unless the address is in the VM
2470 if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2471 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2473 // Set memory to RWX and retry
2474 address page_start =
2475 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2476 bool res = os::protect_memory((char*) page_start, page_size,
2477 os::MEM_PROT_RWX);
2479 if (PrintMiscellaneous && Verbose) {
2480 char buf[256];
2481 jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2482 "at " INTPTR_FORMAT
2483 ", unguarding " INTPTR_FORMAT ": %s", addr,
2484 page_start, (res ? "success" : strerror(errno)));
2485 tty->print_raw_cr(buf);
2486 }
2488 // Set last_addr so if we fault again at the same address, we don't
2489 // end up in an endless loop.
2490 //
2491 // There are two potential complications here. Two threads trapping
2492 // at the same address at the same time could cause one of the
2493 // threads to think it already unguarded, and abort the VM. Likely
2494 // very rare.
2495 //
2496 // The other race involves two threads alternately trapping at
2497 // different addresses and failing to unguard the page, resulting in
2498 // an endless loop. This condition is probably even more unlikely
2499 // than the first.
2500 //
2501 // Although both cases could be avoided by using locks or thread
2502 // local last_addr, these solutions are unnecessary complication:
2503 // this handler is a best-effort safety net, not a complete solution.
2504 // It is disabled by default and should only be used as a workaround
2505 // in case we missed any no-execute-unsafe VM code.
2507 last_addr = addr;
2509 return EXCEPTION_CONTINUE_EXECUTION;
2510 }
2511 }
2513 // Last unguard failed or not unguarding
2514 tty->print_raw_cr("Execution protection violation");
2515 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2516 exceptionInfo->ContextRecord);
2517 return EXCEPTION_CONTINUE_SEARCH;
2518 }
2519 }
2520 #endif // _WIN64
2522 // Check to see if we caught the safepoint code in the
2523 // process of write protecting the memory serialization page.
2524 // It write enables the page immediately after protecting it
2525 // so just return.
2526 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2527 JavaThread* thread = (JavaThread*) t;
2528 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2529 address addr = (address) exceptionRecord->ExceptionInformation[1];
2530 if ( os::is_memory_serialize_page(thread, addr) ) {
2531 // Block current thread until the memory serialize page permission restored.
2532 os::block_on_serialize_page_trap();
2533 return EXCEPTION_CONTINUE_EXECUTION;
2534 }
2535 }
2537 if ((exception_code == EXCEPTION_ACCESS_VIOLATION) &&
2538 VM_Version::is_cpuinfo_segv_addr(pc)) {
2539 // Verify that OS save/restore AVX registers.
2540 return Handle_Exception(exceptionInfo, VM_Version::cpuinfo_cont_addr());
2541 }
2543 if (t != NULL && t->is_Java_thread()) {
2544 JavaThread* thread = (JavaThread*) t;
2545 bool in_java = thread->thread_state() == _thread_in_Java;
2547 // Handle potential stack overflows up front.
2548 if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2549 if (os::uses_stack_guard_pages()) {
2550 #ifdef _M_IA64
2551 // Use guard page for register stack.
2552 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2553 address addr = (address) exceptionRecord->ExceptionInformation[1];
2554 // Check for a register stack overflow on Itanium
2555 if (thread->addr_inside_register_stack_red_zone(addr)) {
2556 // Fatal red zone violation happens if the Java program
2557 // catches a StackOverflow error and does so much processing
2558 // that it runs beyond the unprotected yellow guard zone. As
2559 // a result, we are out of here.
2560 fatal("ERROR: Unrecoverable stack overflow happened. JVM will exit.");
2561 } else if(thread->addr_inside_register_stack(addr)) {
2562 // Disable the yellow zone which sets the state that
2563 // we've got a stack overflow problem.
2564 if (thread->stack_yellow_zone_enabled()) {
2565 thread->disable_stack_yellow_zone();
2566 }
2567 // Give us some room to process the exception.
2568 thread->disable_register_stack_guard();
2569 // Tracing with +Verbose.
2570 if (Verbose) {
2571 tty->print_cr("SOF Compiled Register Stack overflow at " INTPTR_FORMAT " (SIGSEGV)", pc);
2572 tty->print_cr("Register Stack access at " INTPTR_FORMAT, addr);
2573 tty->print_cr("Register Stack base " INTPTR_FORMAT, thread->register_stack_base());
2574 tty->print_cr("Register Stack [" INTPTR_FORMAT "," INTPTR_FORMAT "]",
2575 thread->register_stack_base(),
2576 thread->register_stack_base() + thread->stack_size());
2577 }
2579 // Reguard the permanent register stack red zone just to be sure.
2580 // We saw Windows silently disabling this without telling us.
2581 thread->enable_register_stack_red_zone();
2583 return Handle_Exception(exceptionInfo,
2584 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2585 }
2586 #endif
2587 if (thread->stack_yellow_zone_enabled()) {
2588 // Yellow zone violation. The o/s has unprotected the first yellow
2589 // zone page for us. Note: must call disable_stack_yellow_zone to
2590 // update the enabled status, even if the zone contains only one page.
2591 thread->disable_stack_yellow_zone();
2592 // If not in java code, return and hope for the best.
2593 return in_java ? Handle_Exception(exceptionInfo,
2594 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2595 : EXCEPTION_CONTINUE_EXECUTION;
2596 } else {
2597 // Fatal red zone violation.
2598 thread->disable_stack_red_zone();
2599 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2600 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2601 exceptionInfo->ContextRecord);
2602 return EXCEPTION_CONTINUE_SEARCH;
2603 }
2604 } else if (in_java) {
2605 // JVM-managed guard pages cannot be used on win95/98. The o/s provides
2606 // a one-time-only guard page, which it has released to us. The next
2607 // stack overflow on this thread will result in an ACCESS_VIOLATION.
2608 return Handle_Exception(exceptionInfo,
2609 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2610 } else {
2611 // Can only return and hope for the best. Further stack growth will
2612 // result in an ACCESS_VIOLATION.
2613 return EXCEPTION_CONTINUE_EXECUTION;
2614 }
2615 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2616 // Either stack overflow or null pointer exception.
2617 if (in_java) {
2618 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2619 address addr = (address) exceptionRecord->ExceptionInformation[1];
2620 address stack_end = thread->stack_base() - thread->stack_size();
2621 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2622 // Stack overflow.
2623 assert(!os::uses_stack_guard_pages(),
2624 "should be caught by red zone code above.");
2625 return Handle_Exception(exceptionInfo,
2626 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2627 }
2628 //
2629 // Check for safepoint polling and implicit null
2630 // We only expect null pointers in the stubs (vtable)
2631 // the rest are checked explicitly now.
2632 //
2633 CodeBlob* cb = CodeCache::find_blob(pc);
2634 if (cb != NULL) {
2635 if (os::is_poll_address(addr)) {
2636 address stub = SharedRuntime::get_poll_stub(pc);
2637 return Handle_Exception(exceptionInfo, stub);
2638 }
2639 }
2640 {
2641 #ifdef _WIN64
2642 //
2643 // If it's a legal stack address map the entire region in
2644 //
2645 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2646 address addr = (address) exceptionRecord->ExceptionInformation[1];
2647 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2648 addr = (address)((uintptr_t)addr &
2649 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2650 os::commit_memory((char *)addr, thread->stack_base() - addr,
2651 !ExecMem);
2652 return EXCEPTION_CONTINUE_EXECUTION;
2653 }
2654 else
2655 #endif
2656 {
2657 // Null pointer exception.
2658 #ifdef _M_IA64
2659 // Process implicit null checks in compiled code. Note: Implicit null checks
2660 // can happen even if "ImplicitNullChecks" is disabled, e.g. in vtable stubs.
2661 if (CodeCache::contains((void*) pc_unix_format) && !MacroAssembler::needs_explicit_null_check((intptr_t) addr)) {
2662 CodeBlob *cb = CodeCache::find_blob_unsafe(pc_unix_format);
2663 // Handle implicit null check in UEP method entry
2664 if (cb && (cb->is_frame_complete_at(pc) ||
2665 (cb->is_nmethod() && ((nmethod *)cb)->inlinecache_check_contains(pc)))) {
2666 if (Verbose) {
2667 intptr_t *bundle_start = (intptr_t*) ((intptr_t) pc_unix_format & 0xFFFFFFFFFFFFFFF0);
2668 tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", pc_unix_format);
2669 tty->print_cr(" to addr " INTPTR_FORMAT, addr);
2670 tty->print_cr(" bundle is " INTPTR_FORMAT " (high), " INTPTR_FORMAT " (low)",
2671 *(bundle_start + 1), *bundle_start);
2672 }
2673 return Handle_Exception(exceptionInfo,
2674 SharedRuntime::continuation_for_implicit_exception(thread, pc_unix_format, SharedRuntime::IMPLICIT_NULL));
2675 }
2676 }
2678 // Implicit null checks were processed above. Hence, we should not reach
2679 // here in the usual case => die!
2680 if (Verbose) tty->print_raw_cr("Access violation, possible null pointer exception");
2681 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2682 exceptionInfo->ContextRecord);
2683 return EXCEPTION_CONTINUE_SEARCH;
2685 #else // !IA64
2687 // Windows 98 reports faulting addresses incorrectly
2688 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2689 !os::win32::is_nt()) {
2690 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2691 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2692 }
2693 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2694 exceptionInfo->ContextRecord);
2695 return EXCEPTION_CONTINUE_SEARCH;
2696 #endif
2697 }
2698 }
2699 }
2701 #ifdef _WIN64
2702 // Special care for fast JNI field accessors.
2703 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2704 // in and the heap gets shrunk before the field access.
2705 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2706 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2707 if (addr != (address)-1) {
2708 return Handle_Exception(exceptionInfo, addr);
2709 }
2710 }
2711 #endif
2713 // Stack overflow or null pointer exception in native code.
2714 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2715 exceptionInfo->ContextRecord);
2716 return EXCEPTION_CONTINUE_SEARCH;
2717 } // /EXCEPTION_ACCESS_VIOLATION
2718 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
2719 #if defined _M_IA64
2720 else if ((exception_code == EXCEPTION_ILLEGAL_INSTRUCTION ||
2721 exception_code == EXCEPTION_ILLEGAL_INSTRUCTION_2)) {
2722 M37 handle_wrong_method_break(0, NativeJump::HANDLE_WRONG_METHOD, PR0);
2724 // Compiled method patched to be non entrant? Following conditions must apply:
2725 // 1. must be first instruction in bundle
2726 // 2. must be a break instruction with appropriate code
2727 if((((uint64_t) pc & 0x0F) == 0) &&
2728 (((IPF_Bundle*) pc)->get_slot0() == handle_wrong_method_break.bits())) {
2729 return Handle_Exception(exceptionInfo,
2730 (address)SharedRuntime::get_handle_wrong_method_stub());
2731 }
2732 } // /EXCEPTION_ILLEGAL_INSTRUCTION
2733 #endif
2736 if (in_java) {
2737 switch (exception_code) {
2738 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2739 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2741 case EXCEPTION_INT_OVERFLOW:
2742 return Handle_IDiv_Exception(exceptionInfo);
2744 } // switch
2745 }
2746 #ifndef _WIN64
2747 if (((thread->thread_state() == _thread_in_Java) ||
2748 (thread->thread_state() == _thread_in_native)) &&
2749 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2750 {
2751 LONG result=Handle_FLT_Exception(exceptionInfo);
2752 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2753 }
2754 #endif //_WIN64
2755 }
2757 if (exception_code != EXCEPTION_BREAKPOINT) {
2758 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2759 exceptionInfo->ContextRecord);
2760 }
2761 return EXCEPTION_CONTINUE_SEARCH;
2762 }
2764 #ifndef _WIN64
2765 // Special care for fast JNI accessors.
2766 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2767 // the heap gets shrunk before the field access.
2768 // Need to install our own structured exception handler since native code may
2769 // install its own.
2770 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2771 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2772 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2773 address pc = (address) exceptionInfo->ContextRecord->Eip;
2774 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2775 if (addr != (address)-1) {
2776 return Handle_Exception(exceptionInfo, addr);
2777 }
2778 }
2779 return EXCEPTION_CONTINUE_SEARCH;
2780 }
2782 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2783 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2784 __try { \
2785 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2786 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2787 } \
2788 return 0; \
2789 }
2791 DEFINE_FAST_GETFIELD(jboolean, bool, Boolean)
2792 DEFINE_FAST_GETFIELD(jbyte, byte, Byte)
2793 DEFINE_FAST_GETFIELD(jchar, char, Char)
2794 DEFINE_FAST_GETFIELD(jshort, short, Short)
2795 DEFINE_FAST_GETFIELD(jint, int, Int)
2796 DEFINE_FAST_GETFIELD(jlong, long, Long)
2797 DEFINE_FAST_GETFIELD(jfloat, float, Float)
2798 DEFINE_FAST_GETFIELD(jdouble, double, Double)
2800 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2801 switch (type) {
2802 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2803 case T_BYTE: return (address)jni_fast_GetByteField_wrapper;
2804 case T_CHAR: return (address)jni_fast_GetCharField_wrapper;
2805 case T_SHORT: return (address)jni_fast_GetShortField_wrapper;
2806 case T_INT: return (address)jni_fast_GetIntField_wrapper;
2807 case T_LONG: return (address)jni_fast_GetLongField_wrapper;
2808 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper;
2809 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper;
2810 default: ShouldNotReachHere();
2811 }
2812 return (address)-1;
2813 }
2814 #endif
2816 void os::win32::call_test_func_with_wrapper(void (*funcPtr)(void)) {
2817 // Install a win32 structured exception handler around the test
2818 // function call so the VM can generate an error dump if needed.
2819 __try {
2820 (*funcPtr)();
2821 } __except(topLevelExceptionFilter(
2822 (_EXCEPTION_POINTERS*)_exception_info())) {
2823 // Nothing to do.
2824 }
2825 }
2827 // Virtual Memory
2829 int os::vm_page_size() { return os::win32::vm_page_size(); }
2830 int os::vm_allocation_granularity() {
2831 return os::win32::vm_allocation_granularity();
2832 }
2834 // Windows large page support is available on Windows 2003. In order to use
2835 // large page memory, the administrator must first assign additional privilege
2836 // to the user:
2837 // + select Control Panel -> Administrative Tools -> Local Security Policy
2838 // + select Local Policies -> User Rights Assignment
2839 // + double click "Lock pages in memory", add users and/or groups
2840 // + reboot
2841 // Note the above steps are needed for administrator as well, as administrators
2842 // by default do not have the privilege to lock pages in memory.
2843 //
2844 // Note about Windows 2003: although the API supports committing large page
2845 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2846 // scenario, I found through experiment it only uses large page if the entire
2847 // memory region is reserved and committed in a single VirtualAlloc() call.
2848 // This makes Windows large page support more or less like Solaris ISM, in
2849 // that the entire heap must be committed upfront. This probably will change
2850 // in the future, if so the code below needs to be revisited.
2852 #ifndef MEM_LARGE_PAGES
2853 #define MEM_LARGE_PAGES 0x20000000
2854 #endif
2856 static HANDLE _hProcess;
2857 static HANDLE _hToken;
2859 // Container for NUMA node list info
2860 class NUMANodeListHolder {
2861 private:
2862 int *_numa_used_node_list; // allocated below
2863 int _numa_used_node_count;
2865 void free_node_list() {
2866 if (_numa_used_node_list != NULL) {
2867 FREE_C_HEAP_ARRAY(int, _numa_used_node_list, mtInternal);
2868 }
2869 }
2871 public:
2872 NUMANodeListHolder() {
2873 _numa_used_node_count = 0;
2874 _numa_used_node_list = NULL;
2875 // do rest of initialization in build routine (after function pointers are set up)
2876 }
2878 ~NUMANodeListHolder() {
2879 free_node_list();
2880 }
2882 bool build() {
2883 DWORD_PTR proc_aff_mask;
2884 DWORD_PTR sys_aff_mask;
2885 if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2886 ULONG highest_node_number;
2887 if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false;
2888 free_node_list();
2889 _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal);
2890 for (unsigned int i = 0; i <= highest_node_number; i++) {
2891 ULONGLONG proc_mask_numa_node;
2892 if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2893 if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2894 _numa_used_node_list[_numa_used_node_count++] = i;
2895 }
2896 }
2897 return (_numa_used_node_count > 1);
2898 }
2900 int get_count() {return _numa_used_node_count;}
2901 int get_node_list_entry(int n) {
2902 // for indexes out of range, returns -1
2903 return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2904 }
2906 } numa_node_list_holder;
2910 static size_t _large_page_size = 0;
2912 static bool resolve_functions_for_large_page_init() {
2913 return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2914 os::Advapi32Dll::AdvapiAvailable();
2915 }
2917 static bool request_lock_memory_privilege() {
2918 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2919 os::current_process_id());
2921 LUID luid;
2922 if (_hProcess != NULL &&
2923 os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2924 os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2926 TOKEN_PRIVILEGES tp;
2927 tp.PrivilegeCount = 1;
2928 tp.Privileges[0].Luid = luid;
2929 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2931 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2932 // privilege. Check GetLastError() too. See MSDN document.
2933 if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2934 (GetLastError() == ERROR_SUCCESS)) {
2935 return true;
2936 }
2937 }
2939 return false;
2940 }
2942 static void cleanup_after_large_page_init() {
2943 if (_hProcess) CloseHandle(_hProcess);
2944 _hProcess = NULL;
2945 if (_hToken) CloseHandle(_hToken);
2946 _hToken = NULL;
2947 }
2949 static bool numa_interleaving_init() {
2950 bool success = false;
2951 bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2953 // print a warning if UseNUMAInterleaving flag is specified on command line
2954 bool warn_on_failure = use_numa_interleaving_specified;
2955 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2957 // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2958 size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2959 NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
2961 if (os::Kernel32Dll::NumaCallsAvailable()) {
2962 if (numa_node_list_holder.build()) {
2963 if (PrintMiscellaneous && Verbose) {
2964 tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
2965 for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
2966 tty->print("%d ", numa_node_list_holder.get_node_list_entry(i));
2967 }
2968 tty->print("\n");
2969 }
2970 success = true;
2971 } else {
2972 WARN("Process does not cover multiple NUMA nodes.");
2973 }
2974 } else {
2975 WARN("NUMA Interleaving is not supported by the operating system.");
2976 }
2977 if (!success) {
2978 if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2979 }
2980 return success;
2981 #undef WARN
2982 }
2984 // this routine is used whenever we need to reserve a contiguous VA range
2985 // but we need to make separate VirtualAlloc calls for each piece of the range
2986 // Reasons for doing this:
2987 // * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2988 // * UseNUMAInterleaving requires a separate node for each piece
2989 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
2990 bool should_inject_error=false) {
2991 char * p_buf;
2992 // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2993 size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2994 size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2996 // first reserve enough address space in advance since we want to be
2997 // able to break a single contiguous virtual address range into multiple
2998 // large page commits but WS2003 does not allow reserving large page space
2999 // so we just use 4K pages for reserve, this gives us a legal contiguous
3000 // address space. then we will deallocate that reservation, and re alloc
3001 // using large pages
3002 const size_t size_of_reserve = bytes + chunk_size;
3003 if (bytes > size_of_reserve) {
3004 // Overflowed.
3005 return NULL;
3006 }
3007 p_buf = (char *) VirtualAlloc(addr,
3008 size_of_reserve, // size of Reserve
3009 MEM_RESERVE,
3010 PAGE_READWRITE);
3011 // If reservation failed, return NULL
3012 if (p_buf == NULL) return NULL;
3013 MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
3014 os::release_memory(p_buf, bytes + chunk_size);
3016 // we still need to round up to a page boundary (in case we are using large pages)
3017 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
3018 // instead we handle this in the bytes_to_rq computation below
3019 p_buf = (char *) align_size_up((size_t)p_buf, page_size);
3021 // now go through and allocate one chunk at a time until all bytes are
3022 // allocated
3023 size_t bytes_remaining = bytes;
3024 // An overflow of align_size_up() would have been caught above
3025 // in the calculation of size_of_reserve.
3026 char * next_alloc_addr = p_buf;
3027 HANDLE hProc = GetCurrentProcess();
3029 #ifdef ASSERT
3030 // Variable for the failure injection
3031 long ran_num = os::random();
3032 size_t fail_after = ran_num % bytes;
3033 #endif
3035 int count=0;
3036 while (bytes_remaining) {
3037 // select bytes_to_rq to get to the next chunk_size boundary
3039 size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
3040 // Note allocate and commit
3041 char * p_new;
3043 #ifdef ASSERT
3044 bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
3045 #else
3046 const bool inject_error_now = false;
3047 #endif
3049 if (inject_error_now) {
3050 p_new = NULL;
3051 } else {
3052 if (!UseNUMAInterleaving) {
3053 p_new = (char *) VirtualAlloc(next_alloc_addr,
3054 bytes_to_rq,
3055 flags,
3056 prot);
3057 } else {
3058 // get the next node to use from the used_node_list
3059 assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
3060 DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
3061 p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc,
3062 next_alloc_addr,
3063 bytes_to_rq,
3064 flags,
3065 prot,
3066 node);
3067 }
3068 }
3070 if (p_new == NULL) {
3071 // Free any allocated pages
3072 if (next_alloc_addr > p_buf) {
3073 // Some memory was committed so release it.
3074 size_t bytes_to_release = bytes - bytes_remaining;
3075 // NMT has yet to record any individual blocks, so it
3076 // need to create a dummy 'reserve' record to match
3077 // the release.
3078 MemTracker::record_virtual_memory_reserve((address)p_buf,
3079 bytes_to_release, CALLER_PC);
3080 os::release_memory(p_buf, bytes_to_release);
3081 }
3082 #ifdef ASSERT
3083 if (should_inject_error) {
3084 if (TracePageSizes && Verbose) {
3085 tty->print_cr("Reserving pages individually failed.");
3086 }
3087 }
3088 #endif
3089 return NULL;
3090 }
3092 bytes_remaining -= bytes_to_rq;
3093 next_alloc_addr += bytes_to_rq;
3094 count++;
3095 }
3096 // Although the memory is allocated individually, it is returned as one.
3097 // NMT records it as one block.
3098 if ((flags & MEM_COMMIT) != 0) {
3099 MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC);
3100 } else {
3101 MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC);
3102 }
3104 // made it this far, success
3105 return p_buf;
3106 }
3110 void os::large_page_init() {
3111 if (!UseLargePages) return;
3113 // print a warning if any large page related flag is specified on command line
3114 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
3115 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3116 bool success = false;
3118 # define WARN(msg) if (warn_on_failure) { warning(msg); }
3119 if (resolve_functions_for_large_page_init()) {
3120 if (request_lock_memory_privilege()) {
3121 size_t s = os::Kernel32Dll::GetLargePageMinimum();
3122 if (s) {
3123 #if defined(IA32) || defined(AMD64)
3124 if (s > 4*M || LargePageSizeInBytes > 4*M) {
3125 WARN("JVM cannot use large pages bigger than 4mb.");
3126 } else {
3127 #endif
3128 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
3129 _large_page_size = LargePageSizeInBytes;
3130 } else {
3131 _large_page_size = s;
3132 }
3133 success = true;
3134 #if defined(IA32) || defined(AMD64)
3135 }
3136 #endif
3137 } else {
3138 WARN("Large page is not supported by the processor.");
3139 }
3140 } else {
3141 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
3142 }
3143 } else {
3144 WARN("Large page is not supported by the operating system.");
3145 }
3146 #undef WARN
3148 const size_t default_page_size = (size_t) vm_page_size();
3149 if (success && _large_page_size > default_page_size) {
3150 _page_sizes[0] = _large_page_size;
3151 _page_sizes[1] = default_page_size;
3152 _page_sizes[2] = 0;
3153 }
3155 cleanup_after_large_page_init();
3156 UseLargePages = success;
3157 }
3159 // On win32, one cannot release just a part of reserved memory, it's an
3160 // all or nothing deal. When we split a reservation, we must break the
3161 // reservation into two reservations.
3162 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
3163 bool realloc) {
3164 if (size > 0) {
3165 release_memory(base, size);
3166 if (realloc) {
3167 reserve_memory(split, base);
3168 }
3169 if (size != split) {
3170 reserve_memory(size - split, base + split);
3171 }
3172 }
3173 }
3175 // Multiple threads can race in this code but it's not possible to unmap small sections of
3176 // virtual space to get requested alignment, like posix-like os's.
3177 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
3178 char* os::reserve_memory_aligned(size_t size, size_t alignment) {
3179 assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,
3180 "Alignment must be a multiple of allocation granularity (page size)");
3181 assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");
3183 size_t extra_size = size + alignment;
3184 assert(extra_size >= size, "overflow, size is too large to allow alignment");
3186 char* aligned_base = NULL;
3188 do {
3189 char* extra_base = os::reserve_memory(extra_size, NULL, alignment);
3190 if (extra_base == NULL) {
3191 return NULL;
3192 }
3193 // Do manual alignment
3194 aligned_base = (char*) align_size_up((uintptr_t) extra_base, alignment);
3196 os::release_memory(extra_base, extra_size);
3198 aligned_base = os::reserve_memory(size, aligned_base);
3200 } while (aligned_base == NULL);
3202 return aligned_base;
3203 }
3205 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
3206 assert((size_t)addr % os::vm_allocation_granularity() == 0,
3207 "reserve alignment");
3208 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
3209 char* res;
3210 // note that if UseLargePages is on, all the areas that require interleaving
3211 // will go thru reserve_memory_special rather than thru here.
3212 bool use_individual = (UseNUMAInterleaving && !UseLargePages);
3213 if (!use_individual) {
3214 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
3215 } else {
3216 elapsedTimer reserveTimer;
3217 if( Verbose && PrintMiscellaneous ) reserveTimer.start();
3218 // in numa interleaving, we have to allocate pages individually
3219 // (well really chunks of NUMAInterleaveGranularity size)
3220 res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
3221 if (res == NULL) {
3222 warning("NUMA page allocation failed");
3223 }
3224 if( Verbose && PrintMiscellaneous ) {
3225 reserveTimer.stop();
3226 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3227 reserveTimer.milliseconds(), reserveTimer.ticks());
3228 }
3229 }
3230 assert(res == NULL || addr == NULL || addr == res,
3231 "Unexpected address from reserve.");
3233 return res;
3234 }
3236 // Reserve memory at an arbitrary address, only if that area is
3237 // available (and not reserved for something else).
3238 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3239 // Windows os::reserve_memory() fails of the requested address range is
3240 // not avilable.
3241 return reserve_memory(bytes, requested_addr);
3242 }
3244 size_t os::large_page_size() {
3245 return _large_page_size;
3246 }
3248 bool os::can_commit_large_page_memory() {
3249 // Windows only uses large page memory when the entire region is reserved
3250 // and committed in a single VirtualAlloc() call. This may change in the
3251 // future, but with Windows 2003 it's not possible to commit on demand.
3252 return false;
3253 }
3255 bool os::can_execute_large_page_memory() {
3256 return true;
3257 }
3259 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, bool exec) {
3260 assert(UseLargePages, "only for large pages");
3262 if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3263 return NULL; // Fallback to small pages.
3264 }
3266 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3267 const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3269 // with large pages, there are two cases where we need to use Individual Allocation
3270 // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3271 // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3272 if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3273 if (TracePageSizes && Verbose) {
3274 tty->print_cr("Reserving large pages individually.");
3275 }
3276 char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3277 if (p_buf == NULL) {
3278 // give an appropriate warning message
3279 if (UseNUMAInterleaving) {
3280 warning("NUMA large page allocation failed, UseLargePages flag ignored");
3281 }
3282 if (UseLargePagesIndividualAllocation) {
3283 warning("Individually allocated large pages failed, "
3284 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3285 }
3286 return NULL;
3287 }
3289 return p_buf;
3291 } else {
3292 if (TracePageSizes && Verbose) {
3293 tty->print_cr("Reserving large pages in a single large chunk.");
3294 }
3295 // normal policy just allocate it all at once
3296 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3297 char * res = (char *)VirtualAlloc(addr, bytes, flag, prot);
3298 if (res != NULL) {
3299 MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, CALLER_PC);
3300 }
3302 return res;
3303 }
3304 }
3306 bool os::release_memory_special(char* base, size_t bytes) {
3307 assert(base != NULL, "Sanity check");
3308 return release_memory(base, bytes);
3309 }
3311 void os::print_statistics() {
3312 }
3314 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
3315 int err = os::get_last_error();
3316 char buf[256];
3317 size_t buf_len = os::lasterror(buf, sizeof(buf));
3318 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
3319 ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
3320 exec, buf_len != 0 ? buf : "<no_error_string>", err);
3321 }
3323 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
3324 if (bytes == 0) {
3325 // Don't bother the OS with noops.
3326 return true;
3327 }
3328 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3329 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3330 // Don't attempt to print anything if the OS call fails. We're
3331 // probably low on resources, so the print itself may cause crashes.
3333 // unless we have NUMAInterleaving enabled, the range of a commit
3334 // is always within a reserve covered by a single VirtualAlloc
3335 // in that case we can just do a single commit for the requested size
3336 if (!UseNUMAInterleaving) {
3337 if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
3338 NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3339 return false;
3340 }
3341 if (exec) {
3342 DWORD oldprot;
3343 // Windows doc says to use VirtualProtect to get execute permissions
3344 if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
3345 NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3346 return false;
3347 }
3348 }
3349 return true;
3350 } else {
3352 // when NUMAInterleaving is enabled, the commit might cover a range that
3353 // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3354 // VirtualQuery can help us determine that. The RegionSize that VirtualQuery
3355 // returns represents the number of bytes that can be committed in one step.
3356 size_t bytes_remaining = bytes;
3357 char * next_alloc_addr = addr;
3358 while (bytes_remaining > 0) {
3359 MEMORY_BASIC_INFORMATION alloc_info;
3360 VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3361 size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3362 if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
3363 PAGE_READWRITE) == NULL) {
3364 NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3365 exec);)
3366 return false;
3367 }
3368 if (exec) {
3369 DWORD oldprot;
3370 if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
3371 PAGE_EXECUTE_READWRITE, &oldprot)) {
3372 NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3373 exec);)
3374 return false;
3375 }
3376 }
3377 bytes_remaining -= bytes_to_rq;
3378 next_alloc_addr += bytes_to_rq;
3379 }
3380 }
3381 // if we made it this far, return true
3382 return true;
3383 }
3385 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
3386 bool exec) {
3387 // alignment_hint is ignored on this OS
3388 return pd_commit_memory(addr, size, exec);
3389 }
3391 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
3392 const char* mesg) {
3393 assert(mesg != NULL, "mesg must be specified");
3394 if (!pd_commit_memory(addr, size, exec)) {
3395 warn_fail_commit_memory(addr, size, exec);
3396 vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
3397 }
3398 }
3400 void os::pd_commit_memory_or_exit(char* addr, size_t size,
3401 size_t alignment_hint, bool exec,
3402 const char* mesg) {
3403 // alignment_hint is ignored on this OS
3404 pd_commit_memory_or_exit(addr, size, exec, mesg);
3405 }
3407 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
3408 if (bytes == 0) {
3409 // Don't bother the OS with noops.
3410 return true;
3411 }
3412 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3413 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3414 return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0);
3415 }
3417 bool os::pd_release_memory(char* addr, size_t bytes) {
3418 return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3419 }
3421 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3422 return os::commit_memory(addr, size, !ExecMem);
3423 }
3425 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3426 return os::uncommit_memory(addr, size);
3427 }
3429 // Set protections specified
3430 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3431 bool is_committed) {
3432 unsigned int p = 0;
3433 switch (prot) {
3434 case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3435 case MEM_PROT_READ: p = PAGE_READONLY; break;
3436 case MEM_PROT_RW: p = PAGE_READWRITE; break;
3437 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break;
3438 default:
3439 ShouldNotReachHere();
3440 }
3442 DWORD old_status;
3444 // Strange enough, but on Win32 one can change protection only for committed
3445 // memory, not a big deal anyway, as bytes less or equal than 64K
3446 if (!is_committed) {
3447 commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
3448 "cannot commit protection page");
3449 }
3450 // One cannot use os::guard_memory() here, as on Win32 guard page
3451 // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3452 //
3453 // Pages in the region become guard pages. Any attempt to access a guard page
3454 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3455 // the guard page status. Guard pages thus act as a one-time access alarm.
3456 return VirtualProtect(addr, bytes, p, &old_status) != 0;
3457 }
3459 bool os::guard_memory(char* addr, size_t bytes) {
3460 DWORD old_status;
3461 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3462 }
3464 bool os::unguard_memory(char* addr, size_t bytes) {
3465 DWORD old_status;
3466 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3467 }
3469 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3470 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3471 void os::numa_make_global(char *addr, size_t bytes) { }
3472 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { }
3473 bool os::numa_topology_changed() { return false; }
3474 size_t os::numa_get_groups_num() { return MAX2(numa_node_list_holder.get_count(), 1); }
3475 int os::numa_get_group_id() { return 0; }
3476 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3477 if (numa_node_list_holder.get_count() == 0 && size > 0) {
3478 // Provide an answer for UMA systems
3479 ids[0] = 0;
3480 return 1;
3481 } else {
3482 // check for size bigger than actual groups_num
3483 size = MIN2(size, numa_get_groups_num());
3484 for (int i = 0; i < (int)size; i++) {
3485 ids[i] = numa_node_list_holder.get_node_list_entry(i);
3486 }
3487 return size;
3488 }
3489 }
3491 bool os::get_page_info(char *start, page_info* info) {
3492 return false;
3493 }
3495 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3496 return end;
3497 }
3499 char* os::non_memory_address_word() {
3500 // Must never look like an address returned by reserve_memory,
3501 // even in its subfields (as defined by the CPU immediate fields,
3502 // if the CPU splits constants across multiple instructions).
3503 return (char*)-1;
3504 }
3506 #define MAX_ERROR_COUNT 100
3507 #define SYS_THREAD_ERROR 0xffffffffUL
3509 void os::pd_start_thread(Thread* thread) {
3510 DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3511 // Returns previous suspend state:
3512 // 0: Thread was not suspended
3513 // 1: Thread is running now
3514 // >1: Thread is still suspended.
3515 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3516 }
3518 class HighResolutionInterval : public CHeapObj<mtThread> {
3519 // The default timer resolution seems to be 10 milliseconds.
3520 // (Where is this written down?)
3521 // If someone wants to sleep for only a fraction of the default,
3522 // then we set the timer resolution down to 1 millisecond for
3523 // the duration of their interval.
3524 // We carefully set the resolution back, since otherwise we
3525 // seem to incur an overhead (3%?) that we don't need.
3526 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3527 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3528 // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3529 // timeBeginPeriod() if the relative error exceeded some threshold.
3530 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3531 // to decreased efficiency related to increased timer "tick" rates. We want to minimize
3532 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3533 // resolution timers running.
3534 private:
3535 jlong resolution;
3536 public:
3537 HighResolutionInterval(jlong ms) {
3538 resolution = ms % 10L;
3539 if (resolution != 0) {
3540 MMRESULT result = timeBeginPeriod(1L);
3541 }
3542 }
3543 ~HighResolutionInterval() {
3544 if (resolution != 0) {
3545 MMRESULT result = timeEndPeriod(1L);
3546 }
3547 resolution = 0L;
3548 }
3549 };
3551 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3552 jlong limit = (jlong) MAXDWORD;
3554 while(ms > limit) {
3555 int res;
3556 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3557 return res;
3558 ms -= limit;
3559 }
3561 assert(thread == Thread::current(), "thread consistency check");
3562 OSThread* osthread = thread->osthread();
3563 OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3564 int result;
3565 if (interruptable) {
3566 assert(thread->is_Java_thread(), "must be java thread");
3567 JavaThread *jt = (JavaThread *) thread;
3568 ThreadBlockInVM tbivm(jt);
3570 jt->set_suspend_equivalent();
3571 // cleared by handle_special_suspend_equivalent_condition() or
3572 // java_suspend_self() via check_and_wait_while_suspended()
3574 HANDLE events[1];
3575 events[0] = osthread->interrupt_event();
3576 HighResolutionInterval *phri=NULL;
3577 if(!ForceTimeHighResolution)
3578 phri = new HighResolutionInterval( ms );
3579 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3580 result = OS_TIMEOUT;
3581 } else {
3582 ResetEvent(osthread->interrupt_event());
3583 osthread->set_interrupted(false);
3584 result = OS_INTRPT;
3585 }
3586 delete phri; //if it is NULL, harmless
3588 // were we externally suspended while we were waiting?
3589 jt->check_and_wait_while_suspended();
3590 } else {
3591 assert(!thread->is_Java_thread(), "must not be java thread");
3592 Sleep((long) ms);
3593 result = OS_TIMEOUT;
3594 }
3595 return result;
3596 }
3598 //
3599 // Short sleep, direct OS call.
3600 //
3601 // ms = 0, means allow others (if any) to run.
3602 //
3603 void os::naked_short_sleep(jlong ms) {
3604 assert(ms < 1000, "Un-interruptable sleep, short time use only");
3605 Sleep(ms);
3606 }
3608 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3609 void os::infinite_sleep() {
3610 while (true) { // sleep forever ...
3611 Sleep(100000); // ... 100 seconds at a time
3612 }
3613 }
3615 typedef BOOL (WINAPI * STTSignature)(void) ;
3617 os::YieldResult os::NakedYield() {
3618 // Use either SwitchToThread() or Sleep(0)
3619 // Consider passing back the return value from SwitchToThread().
3620 if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3621 return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3622 } else {
3623 Sleep(0);
3624 }
3625 return os::YIELD_UNKNOWN ;
3626 }
3628 void os::yield() { os::NakedYield(); }
3630 void os::yield_all(int attempts) {
3631 // Yields to all threads, including threads with lower priorities
3632 Sleep(1);
3633 }
3635 // Win32 only gives you access to seven real priorities at a time,
3636 // so we compress Java's ten down to seven. It would be better
3637 // if we dynamically adjusted relative priorities.
3639 int os::java_to_os_priority[CriticalPriority + 1] = {
3640 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3641 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3642 THREAD_PRIORITY_LOWEST, // 2
3643 THREAD_PRIORITY_BELOW_NORMAL, // 3
3644 THREAD_PRIORITY_BELOW_NORMAL, // 4
3645 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3646 THREAD_PRIORITY_NORMAL, // 6
3647 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3648 THREAD_PRIORITY_ABOVE_NORMAL, // 8
3649 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3650 THREAD_PRIORITY_HIGHEST, // 10 MaxPriority
3651 THREAD_PRIORITY_HIGHEST // 11 CriticalPriority
3652 };
3654 int prio_policy1[CriticalPriority + 1] = {
3655 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3656 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3657 THREAD_PRIORITY_LOWEST, // 2
3658 THREAD_PRIORITY_BELOW_NORMAL, // 3
3659 THREAD_PRIORITY_BELOW_NORMAL, // 4
3660 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3661 THREAD_PRIORITY_ABOVE_NORMAL, // 6
3662 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3663 THREAD_PRIORITY_HIGHEST, // 8
3664 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3665 THREAD_PRIORITY_TIME_CRITICAL, // 10 MaxPriority
3666 THREAD_PRIORITY_TIME_CRITICAL // 11 CriticalPriority
3667 };
3669 static int prio_init() {
3670 // If ThreadPriorityPolicy is 1, switch tables
3671 if (ThreadPriorityPolicy == 1) {
3672 int i;
3673 for (i = 0; i < CriticalPriority + 1; i++) {
3674 os::java_to_os_priority[i] = prio_policy1[i];
3675 }
3676 }
3677 if (UseCriticalJavaThreadPriority) {
3678 os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority] ;
3679 }
3680 return 0;
3681 }
3683 OSReturn os::set_native_priority(Thread* thread, int priority) {
3684 if (!UseThreadPriorities) return OS_OK;
3685 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3686 return ret ? OS_OK : OS_ERR;
3687 }
3689 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3690 if ( !UseThreadPriorities ) {
3691 *priority_ptr = java_to_os_priority[NormPriority];
3692 return OS_OK;
3693 }
3694 int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3695 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3696 assert(false, "GetThreadPriority failed");
3697 return OS_ERR;
3698 }
3699 *priority_ptr = os_prio;
3700 return OS_OK;
3701 }
3704 // Hint to the underlying OS that a task switch would not be good.
3705 // Void return because it's a hint and can fail.
3706 void os::hint_no_preempt() {}
3708 void os::interrupt(Thread* thread) {
3709 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3710 "possibility of dangling Thread pointer");
3712 OSThread* osthread = thread->osthread();
3713 osthread->set_interrupted(true);
3714 // More than one thread can get here with the same value of osthread,
3715 // resulting in multiple notifications. We do, however, want the store
3716 // to interrupted() to be visible to other threads before we post
3717 // the interrupt event.
3718 OrderAccess::release();
3719 SetEvent(osthread->interrupt_event());
3720 // For JSR166: unpark after setting status
3721 if (thread->is_Java_thread())
3722 ((JavaThread*)thread)->parker()->unpark();
3724 ParkEvent * ev = thread->_ParkEvent ;
3725 if (ev != NULL) ev->unpark() ;
3727 }
3730 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3731 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3732 "possibility of dangling Thread pointer");
3734 OSThread* osthread = thread->osthread();
3735 // There is no synchronization between the setting of the interrupt
3736 // and it being cleared here. It is critical - see 6535709 - that
3737 // we only clear the interrupt state, and reset the interrupt event,
3738 // if we are going to report that we were indeed interrupted - else
3739 // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3740 // depending on the timing. By checking thread interrupt event to see
3741 // if the thread gets real interrupt thus prevent spurious wakeup.
3742 bool interrupted = osthread->interrupted() && (WaitForSingleObject(osthread->interrupt_event(), 0) == WAIT_OBJECT_0);
3743 if (interrupted && clear_interrupted) {
3744 osthread->set_interrupted(false);
3745 ResetEvent(osthread->interrupt_event());
3746 } // Otherwise leave the interrupted state alone
3748 return interrupted;
3749 }
3751 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3752 ExtendedPC os::get_thread_pc(Thread* thread) {
3753 CONTEXT context;
3754 context.ContextFlags = CONTEXT_CONTROL;
3755 HANDLE handle = thread->osthread()->thread_handle();
3756 #ifdef _M_IA64
3757 assert(0, "Fix get_thread_pc");
3758 return ExtendedPC(NULL);
3759 #else
3760 if (GetThreadContext(handle, &context)) {
3761 #ifdef _M_AMD64
3762 return ExtendedPC((address) context.Rip);
3763 #else
3764 return ExtendedPC((address) context.Eip);
3765 #endif
3766 } else {
3767 return ExtendedPC(NULL);
3768 }
3769 #endif
3770 }
3772 // GetCurrentThreadId() returns DWORD
3773 intx os::current_thread_id() { return GetCurrentThreadId(); }
3775 static int _initial_pid = 0;
3777 int os::current_process_id()
3778 {
3779 return (_initial_pid ? _initial_pid : _getpid());
3780 }
3782 int os::win32::_vm_page_size = 0;
3783 int os::win32::_vm_allocation_granularity = 0;
3784 int os::win32::_processor_type = 0;
3785 // Processor level is not available on non-NT systems, use vm_version instead
3786 int os::win32::_processor_level = 0;
3787 julong os::win32::_physical_memory = 0;
3788 size_t os::win32::_default_stack_size = 0;
3790 intx os::win32::_os_thread_limit = 0;
3791 volatile intx os::win32::_os_thread_count = 0;
3793 bool os::win32::_is_nt = false;
3794 bool os::win32::_is_windows_2003 = false;
3795 bool os::win32::_is_windows_server = false;
3797 void os::win32::initialize_system_info() {
3798 SYSTEM_INFO si;
3799 GetSystemInfo(&si);
3800 _vm_page_size = si.dwPageSize;
3801 _vm_allocation_granularity = si.dwAllocationGranularity;
3802 _processor_type = si.dwProcessorType;
3803 _processor_level = si.wProcessorLevel;
3804 set_processor_count(si.dwNumberOfProcessors);
3806 MEMORYSTATUSEX ms;
3807 ms.dwLength = sizeof(ms);
3809 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3810 // dwMemoryLoad (% of memory in use)
3811 GlobalMemoryStatusEx(&ms);
3812 _physical_memory = ms.ullTotalPhys;
3814 OSVERSIONINFOEX oi;
3815 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3816 GetVersionEx((OSVERSIONINFO*)&oi);
3817 switch(oi.dwPlatformId) {
3818 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3819 case VER_PLATFORM_WIN32_NT:
3820 _is_nt = true;
3821 {
3822 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3823 if (os_vers == 5002) {
3824 _is_windows_2003 = true;
3825 }
3826 if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3827 oi.wProductType == VER_NT_SERVER) {
3828 _is_windows_server = true;
3829 }
3830 }
3831 break;
3832 default: fatal("Unknown platform");
3833 }
3835 _default_stack_size = os::current_stack_size();
3836 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3837 assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3838 "stack size not a multiple of page size");
3840 initialize_performance_counter();
3842 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3843 // known to deadlock the system, if the VM issues to thread operations with
3844 // a too high frequency, e.g., such as changing the priorities.
3845 // The 6000 seems to work well - no deadlocks has been notices on the test
3846 // programs that we have seen experience this problem.
3847 if (!os::win32::is_nt()) {
3848 StarvationMonitorInterval = 6000;
3849 }
3850 }
3853 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3854 char path[MAX_PATH];
3855 DWORD size;
3856 DWORD pathLen = (DWORD)sizeof(path);
3857 HINSTANCE result = NULL;
3859 // only allow library name without path component
3860 assert(strchr(name, '\\') == NULL, "path not allowed");
3861 assert(strchr(name, ':') == NULL, "path not allowed");
3862 if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3863 jio_snprintf(ebuf, ebuflen,
3864 "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3865 return NULL;
3866 }
3868 // search system directory
3869 if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3870 strcat(path, "\\");
3871 strcat(path, name);
3872 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3873 return result;
3874 }
3875 }
3877 // try Windows directory
3878 if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3879 strcat(path, "\\");
3880 strcat(path, name);
3881 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3882 return result;
3883 }
3884 }
3886 jio_snprintf(ebuf, ebuflen,
3887 "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3888 return NULL;
3889 }
3891 void os::win32::setmode_streams() {
3892 _setmode(_fileno(stdin), _O_BINARY);
3893 _setmode(_fileno(stdout), _O_BINARY);
3894 _setmode(_fileno(stderr), _O_BINARY);
3895 }
3898 bool os::is_debugger_attached() {
3899 return IsDebuggerPresent() ? true : false;
3900 }
3903 void os::wait_for_keypress_at_exit(void) {
3904 if (PauseAtExit) {
3905 fprintf(stderr, "Press any key to continue...\n");
3906 fgetc(stdin);
3907 }
3908 }
3911 int os::message_box(const char* title, const char* message) {
3912 int result = MessageBox(NULL, message, title,
3913 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3914 return result == IDYES;
3915 }
3917 int os::allocate_thread_local_storage() {
3918 return TlsAlloc();
3919 }
3922 void os::free_thread_local_storage(int index) {
3923 TlsFree(index);
3924 }
3927 void os::thread_local_storage_at_put(int index, void* value) {
3928 TlsSetValue(index, value);
3929 assert(thread_local_storage_at(index) == value, "Just checking");
3930 }
3933 void* os::thread_local_storage_at(int index) {
3934 return TlsGetValue(index);
3935 }
3938 #ifndef PRODUCT
3939 #ifndef _WIN64
3940 // Helpers to check whether NX protection is enabled
3941 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3942 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3943 pex->ExceptionRecord->NumberParameters > 0 &&
3944 pex->ExceptionRecord->ExceptionInformation[0] ==
3945 EXCEPTION_INFO_EXEC_VIOLATION) {
3946 return EXCEPTION_EXECUTE_HANDLER;
3947 }
3948 return EXCEPTION_CONTINUE_SEARCH;
3949 }
3951 void nx_check_protection() {
3952 // If NX is enabled we'll get an exception calling into code on the stack
3953 char code[] = { (char)0xC3 }; // ret
3954 void *code_ptr = (void *)code;
3955 __try {
3956 __asm call code_ptr
3957 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3958 tty->print_raw_cr("NX protection detected.");
3959 }
3960 }
3961 #endif // _WIN64
3962 #endif // PRODUCT
3964 // this is called _before_ the global arguments have been parsed
3965 void os::init(void) {
3966 _initial_pid = _getpid();
3968 init_random(1234567);
3970 win32::initialize_system_info();
3971 win32::setmode_streams();
3972 init_page_sizes((size_t) win32::vm_page_size());
3974 // For better scalability on MP systems (must be called after initialize_system_info)
3975 #ifndef PRODUCT
3976 if (is_MP()) {
3977 NoYieldsInMicrolock = true;
3978 }
3979 #endif
3980 // This may be overridden later when argument processing is done.
3981 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3982 os::win32::is_windows_2003());
3984 // Initialize main_process and main_thread
3985 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle
3986 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3987 &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3988 fatal("DuplicateHandle failed\n");
3989 }
3990 main_thread_id = (int) GetCurrentThreadId();
3991 }
3993 // To install functions for atexit processing
3994 extern "C" {
3995 static void perfMemory_exit_helper() {
3996 perfMemory_exit();
3997 }
3998 }
4000 static jint initSock();
4002 // this is called _after_ the global arguments have been parsed
4003 jint os::init_2(void) {
4004 // Allocate a single page and mark it as readable for safepoint polling
4005 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
4006 guarantee( polling_page != NULL, "Reserve Failed for polling page");
4008 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
4009 guarantee( return_page != NULL, "Commit Failed for polling page");
4011 os::set_polling_page( polling_page );
4013 #ifndef PRODUCT
4014 if( Verbose && PrintMiscellaneous )
4015 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
4016 #endif
4018 if (!UseMembar) {
4019 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
4020 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
4022 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
4023 guarantee( return_page != NULL, "Commit Failed for memory serialize page");
4025 os::set_memory_serialize_page( mem_serialize_page );
4027 #ifndef PRODUCT
4028 if(Verbose && PrintMiscellaneous)
4029 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
4030 #endif
4031 }
4033 // Setup Windows Exceptions
4035 // for debugging float code generation bugs
4036 if (ForceFloatExceptions) {
4037 #ifndef _WIN64
4038 static long fp_control_word = 0;
4039 __asm { fstcw fp_control_word }
4040 // see Intel PPro Manual, Vol. 2, p 7-16
4041 const long precision = 0x20;
4042 const long underflow = 0x10;
4043 const long overflow = 0x08;
4044 const long zero_div = 0x04;
4045 const long denorm = 0x02;
4046 const long invalid = 0x01;
4047 fp_control_word |= invalid;
4048 __asm { fldcw fp_control_word }
4049 #endif
4050 }
4052 // If stack_commit_size is 0, windows will reserve the default size,
4053 // but only commit a small portion of it.
4054 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
4055 size_t default_reserve_size = os::win32::default_stack_size();
4056 size_t actual_reserve_size = stack_commit_size;
4057 if (stack_commit_size < default_reserve_size) {
4058 // If stack_commit_size == 0, we want this too
4059 actual_reserve_size = default_reserve_size;
4060 }
4062 // Check minimum allowable stack size for thread creation and to initialize
4063 // the java system classes, including StackOverflowError - depends on page
4064 // size. Add a page for compiler2 recursion in main thread.
4065 // Add in 2*BytesPerWord times page size to account for VM stack during
4066 // class initialization depending on 32 or 64 bit VM.
4067 size_t min_stack_allowed =
4068 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4069 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
4070 if (actual_reserve_size < min_stack_allowed) {
4071 tty->print_cr("\nThe stack size specified is too small, "
4072 "Specify at least %dk",
4073 min_stack_allowed / K);
4074 return JNI_ERR;
4075 }
4077 JavaThread::set_stack_size_at_create(stack_commit_size);
4079 // Calculate theoretical max. size of Threads to guard gainst artifical
4080 // out-of-memory situations, where all available address-space has been
4081 // reserved by thread stacks.
4082 assert(actual_reserve_size != 0, "Must have a stack");
4084 // Calculate the thread limit when we should start doing Virtual Memory
4085 // banging. Currently when the threads will have used all but 200Mb of space.
4086 //
4087 // TODO: consider performing a similar calculation for commit size instead
4088 // as reserve size, since on a 64-bit platform we'll run into that more
4089 // often than running out of virtual memory space. We can use the
4090 // lower value of the two calculations as the os_thread_limit.
4091 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
4092 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
4094 // at exit methods are called in the reverse order of their registration.
4095 // there is no limit to the number of functions registered. atexit does
4096 // not set errno.
4098 if (PerfAllowAtExitRegistration) {
4099 // only register atexit functions if PerfAllowAtExitRegistration is set.
4100 // atexit functions can be delayed until process exit time, which
4101 // can be problematic for embedded VM situations. Embedded VMs should
4102 // call DestroyJavaVM() to assure that VM resources are released.
4104 // note: perfMemory_exit_helper atexit function may be removed in
4105 // the future if the appropriate cleanup code can be added to the
4106 // VM_Exit VMOperation's doit method.
4107 if (atexit(perfMemory_exit_helper) != 0) {
4108 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4109 }
4110 }
4112 #ifndef _WIN64
4113 // Print something if NX is enabled (win32 on AMD64)
4114 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4115 #endif
4117 // initialize thread priority policy
4118 prio_init();
4120 if (UseNUMA && !ForceNUMA) {
4121 UseNUMA = false; // We don't fully support this yet
4122 }
4124 if (UseNUMAInterleaving) {
4125 // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4126 bool success = numa_interleaving_init();
4127 if (!success) UseNUMAInterleaving = false;
4128 }
4130 if (initSock() != JNI_OK) {
4131 return JNI_ERR;
4132 }
4134 return JNI_OK;
4135 }
4137 // Mark the polling page as unreadable
4138 void os::make_polling_page_unreadable(void) {
4139 DWORD old_status;
4140 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
4141 fatal("Could not disable polling page");
4142 };
4144 // Mark the polling page as readable
4145 void os::make_polling_page_readable(void) {
4146 DWORD old_status;
4147 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
4148 fatal("Could not enable polling page");
4149 };
4152 int os::stat(const char *path, struct stat *sbuf) {
4153 char pathbuf[MAX_PATH];
4154 if (strlen(path) > MAX_PATH - 1) {
4155 errno = ENAMETOOLONG;
4156 return -1;
4157 }
4158 os::native_path(strcpy(pathbuf, path));
4159 int ret = ::stat(pathbuf, sbuf);
4160 if (sbuf != NULL && UseUTCFileTimestamp) {
4161 // Fix for 6539723. st_mtime returned from stat() is dependent on
4162 // the system timezone and so can return different values for the
4163 // same file if/when daylight savings time changes. This adjustment
4164 // makes sure the same timestamp is returned regardless of the TZ.
4165 //
4166 // See:
4167 // http://msdn.microsoft.com/library/
4168 // default.asp?url=/library/en-us/sysinfo/base/
4169 // time_zone_information_str.asp
4170 // and
4171 // http://msdn.microsoft.com/library/default.asp?url=
4172 // /library/en-us/sysinfo/base/settimezoneinformation.asp
4173 //
4174 // NOTE: there is a insidious bug here: If the timezone is changed
4175 // after the call to stat() but before 'GetTimeZoneInformation()', then
4176 // the adjustment we do here will be wrong and we'll return the wrong
4177 // value (which will likely end up creating an invalid class data
4178 // archive). Absent a better API for this, or some time zone locking
4179 // mechanism, we'll have to live with this risk.
4180 TIME_ZONE_INFORMATION tz;
4181 DWORD tzid = GetTimeZoneInformation(&tz);
4182 int daylightBias =
4183 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias;
4184 sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
4185 }
4186 return ret;
4187 }
4190 #define FT2INT64(ft) \
4191 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4194 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4195 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4196 // of a thread.
4197 //
4198 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4199 // the fast estimate available on the platform.
4201 // current_thread_cpu_time() is not optimized for Windows yet
4202 jlong os::current_thread_cpu_time() {
4203 // return user + sys since the cost is the same
4204 return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4205 }
4207 jlong os::thread_cpu_time(Thread* thread) {
4208 // consistent with what current_thread_cpu_time() returns.
4209 return os::thread_cpu_time(thread, true /* user+sys */);
4210 }
4212 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4213 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4214 }
4216 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4217 // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4218 // If this function changes, os::is_thread_cpu_time_supported() should too
4219 if (os::win32::is_nt()) {
4220 FILETIME CreationTime;
4221 FILETIME ExitTime;
4222 FILETIME KernelTime;
4223 FILETIME UserTime;
4225 if ( GetThreadTimes(thread->osthread()->thread_handle(),
4226 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4227 return -1;
4228 else
4229 if (user_sys_cpu_time) {
4230 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4231 } else {
4232 return FT2INT64(UserTime) * 100;
4233 }
4234 } else {
4235 return (jlong) timeGetTime() * 1000000;
4236 }
4237 }
4239 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4240 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
4241 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
4242 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
4243 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
4244 }
4246 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4247 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
4248 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
4249 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
4250 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
4251 }
4253 bool os::is_thread_cpu_time_supported() {
4254 // see os::thread_cpu_time
4255 if (os::win32::is_nt()) {
4256 FILETIME CreationTime;
4257 FILETIME ExitTime;
4258 FILETIME KernelTime;
4259 FILETIME UserTime;
4261 if ( GetThreadTimes(GetCurrentThread(),
4262 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4263 return false;
4264 else
4265 return true;
4266 } else {
4267 return false;
4268 }
4269 }
4271 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4272 // It does have primitives (PDH API) to get CPU usage and run queue length.
4273 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4274 // If we wanted to implement loadavg on Windows, we have a few options:
4275 //
4276 // a) Query CPU usage and run queue length and "fake" an answer by
4277 // returning the CPU usage if it's under 100%, and the run queue
4278 // length otherwise. It turns out that querying is pretty slow
4279 // on Windows, on the order of 200 microseconds on a fast machine.
4280 // Note that on the Windows the CPU usage value is the % usage
4281 // since the last time the API was called (and the first call
4282 // returns 100%), so we'd have to deal with that as well.
4283 //
4284 // b) Sample the "fake" answer using a sampling thread and store
4285 // the answer in a global variable. The call to loadavg would
4286 // just return the value of the global, avoiding the slow query.
4287 //
4288 // c) Sample a better answer using exponential decay to smooth the
4289 // value. This is basically the algorithm used by UNIX kernels.
4290 //
4291 // Note that sampling thread starvation could affect both (b) and (c).
4292 int os::loadavg(double loadavg[], int nelem) {
4293 return -1;
4294 }
4297 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4298 bool os::dont_yield() {
4299 return DontYieldALot;
4300 }
4302 // This method is a slightly reworked copy of JDK's sysOpen
4303 // from src/windows/hpi/src/sys_api_md.c
4305 int os::open(const char *path, int oflag, int mode) {
4306 char pathbuf[MAX_PATH];
4308 if (strlen(path) > MAX_PATH - 1) {
4309 errno = ENAMETOOLONG;
4310 return -1;
4311 }
4312 os::native_path(strcpy(pathbuf, path));
4313 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4314 }
4316 FILE* os::open(int fd, const char* mode) {
4317 return ::_fdopen(fd, mode);
4318 }
4320 // Is a (classpath) directory empty?
4321 bool os::dir_is_empty(const char* path) {
4322 WIN32_FIND_DATA fd;
4323 HANDLE f = FindFirstFile(path, &fd);
4324 if (f == INVALID_HANDLE_VALUE) {
4325 return true;
4326 }
4327 FindClose(f);
4328 return false;
4329 }
4331 // create binary file, rewriting existing file if required
4332 int os::create_binary_file(const char* path, bool rewrite_existing) {
4333 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4334 if (!rewrite_existing) {
4335 oflags |= _O_EXCL;
4336 }
4337 return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4338 }
4340 // return current position of file pointer
4341 jlong os::current_file_offset(int fd) {
4342 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4343 }
4345 // move file pointer to the specified offset
4346 jlong os::seek_to_file_offset(int fd, jlong offset) {
4347 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4348 }
4351 jlong os::lseek(int fd, jlong offset, int whence) {
4352 return (jlong) ::_lseeki64(fd, offset, whence);
4353 }
4355 // This method is a slightly reworked copy of JDK's sysNativePath
4356 // from src/windows/hpi/src/path_md.c
4358 /* Convert a pathname to native format. On win32, this involves forcing all
4359 separators to be '\\' rather than '/' (both are legal inputs, but Win95
4360 sometimes rejects '/') and removing redundant separators. The input path is
4361 assumed to have been converted into the character encoding used by the local
4362 system. Because this might be a double-byte encoding, care is taken to
4363 treat double-byte lead characters correctly.
4365 This procedure modifies the given path in place, as the result is never
4366 longer than the original. There is no error return; this operation always
4367 succeeds. */
4368 char * os::native_path(char *path) {
4369 char *src = path, *dst = path, *end = path;
4370 char *colon = NULL; /* If a drive specifier is found, this will
4371 point to the colon following the drive
4372 letter */
4374 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4375 assert(((!::IsDBCSLeadByte('/'))
4376 && (!::IsDBCSLeadByte('\\'))
4377 && (!::IsDBCSLeadByte(':'))),
4378 "Illegal lead byte");
4380 /* Check for leading separators */
4381 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4382 while (isfilesep(*src)) {
4383 src++;
4384 }
4386 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4387 /* Remove leading separators if followed by drive specifier. This
4388 hack is necessary to support file URLs containing drive
4389 specifiers (e.g., "file://c:/path"). As a side effect,
4390 "/c:/path" can be used as an alternative to "c:/path". */
4391 *dst++ = *src++;
4392 colon = dst;
4393 *dst++ = ':';
4394 src++;
4395 } else {
4396 src = path;
4397 if (isfilesep(src[0]) && isfilesep(src[1])) {
4398 /* UNC pathname: Retain first separator; leave src pointed at
4399 second separator so that further separators will be collapsed
4400 into the second separator. The result will be a pathname
4401 beginning with "\\\\" followed (most likely) by a host name. */
4402 src = dst = path + 1;
4403 path[0] = '\\'; /* Force first separator to '\\' */
4404 }
4405 }
4407 end = dst;
4409 /* Remove redundant separators from remainder of path, forcing all
4410 separators to be '\\' rather than '/'. Also, single byte space
4411 characters are removed from the end of the path because those
4412 are not legal ending characters on this operating system.
4413 */
4414 while (*src != '\0') {
4415 if (isfilesep(*src)) {
4416 *dst++ = '\\'; src++;
4417 while (isfilesep(*src)) src++;
4418 if (*src == '\0') {
4419 /* Check for trailing separator */
4420 end = dst;
4421 if (colon == dst - 2) break; /* "z:\\" */
4422 if (dst == path + 1) break; /* "\\" */
4423 if (dst == path + 2 && isfilesep(path[0])) {
4424 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4425 beginning of a UNC pathname. Even though it is not, by
4426 itself, a valid UNC pathname, we leave it as is in order
4427 to be consistent with the path canonicalizer as well
4428 as the win32 APIs, which treat this case as an invalid
4429 UNC pathname rather than as an alias for the root
4430 directory of the current drive. */
4431 break;
4432 }
4433 end = --dst; /* Path does not denote a root directory, so
4434 remove trailing separator */
4435 break;
4436 }
4437 end = dst;
4438 } else {
4439 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4440 *dst++ = *src++;
4441 if (*src) *dst++ = *src++;
4442 end = dst;
4443 } else { /* Copy a single-byte character */
4444 char c = *src++;
4445 *dst++ = c;
4446 /* Space is not a legal ending character */
4447 if (c != ' ') end = dst;
4448 }
4449 }
4450 }
4452 *end = '\0';
4454 /* For "z:", add "." to work around a bug in the C runtime library */
4455 if (colon == dst - 1) {
4456 path[2] = '.';
4457 path[3] = '\0';
4458 }
4460 return path;
4461 }
4463 // This code is a copy of JDK's sysSetLength
4464 // from src/windows/hpi/src/sys_api_md.c
4466 int os::ftruncate(int fd, jlong length) {
4467 HANDLE h = (HANDLE)::_get_osfhandle(fd);
4468 long high = (long)(length >> 32);
4469 DWORD ret;
4471 if (h == (HANDLE)(-1)) {
4472 return -1;
4473 }
4475 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4476 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4477 return -1;
4478 }
4480 if (::SetEndOfFile(h) == FALSE) {
4481 return -1;
4482 }
4484 return 0;
4485 }
4488 // This code is a copy of JDK's sysSync
4489 // from src/windows/hpi/src/sys_api_md.c
4490 // except for the legacy workaround for a bug in Win 98
4492 int os::fsync(int fd) {
4493 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4495 if ( (!::FlushFileBuffers(handle)) &&
4496 (GetLastError() != ERROR_ACCESS_DENIED) ) {
4497 /* from winerror.h */
4498 return -1;
4499 }
4500 return 0;
4501 }
4503 static int nonSeekAvailable(int, long *);
4504 static int stdinAvailable(int, long *);
4506 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR)
4507 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO)
4509 // This code is a copy of JDK's sysAvailable
4510 // from src/windows/hpi/src/sys_api_md.c
4512 int os::available(int fd, jlong *bytes) {
4513 jlong cur, end;
4514 struct _stati64 stbuf64;
4516 if (::_fstati64(fd, &stbuf64) >= 0) {
4517 int mode = stbuf64.st_mode;
4518 if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4519 int ret;
4520 long lpbytes;
4521 if (fd == 0) {
4522 ret = stdinAvailable(fd, &lpbytes);
4523 } else {
4524 ret = nonSeekAvailable(fd, &lpbytes);
4525 }
4526 (*bytes) = (jlong)(lpbytes);
4527 return ret;
4528 }
4529 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4530 return FALSE;
4531 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4532 return FALSE;
4533 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4534 return FALSE;
4535 }
4536 *bytes = end - cur;
4537 return TRUE;
4538 } else {
4539 return FALSE;
4540 }
4541 }
4543 // This code is a copy of JDK's nonSeekAvailable
4544 // from src/windows/hpi/src/sys_api_md.c
4546 static int nonSeekAvailable(int fd, long *pbytes) {
4547 /* This is used for available on non-seekable devices
4548 * (like both named and anonymous pipes, such as pipes
4549 * connected to an exec'd process).
4550 * Standard Input is a special case.
4551 *
4552 */
4553 HANDLE han;
4555 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4556 return FALSE;
4557 }
4559 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4560 /* PeekNamedPipe fails when at EOF. In that case we
4561 * simply make *pbytes = 0 which is consistent with the
4562 * behavior we get on Solaris when an fd is at EOF.
4563 * The only alternative is to raise an Exception,
4564 * which isn't really warranted.
4565 */
4566 if (::GetLastError() != ERROR_BROKEN_PIPE) {
4567 return FALSE;
4568 }
4569 *pbytes = 0;
4570 }
4571 return TRUE;
4572 }
4574 #define MAX_INPUT_EVENTS 2000
4576 // This code is a copy of JDK's stdinAvailable
4577 // from src/windows/hpi/src/sys_api_md.c
4579 static int stdinAvailable(int fd, long *pbytes) {
4580 HANDLE han;
4581 DWORD numEventsRead = 0; /* Number of events read from buffer */
4582 DWORD numEvents = 0; /* Number of events in buffer */
4583 DWORD i = 0; /* Loop index */
4584 DWORD curLength = 0; /* Position marker */
4585 DWORD actualLength = 0; /* Number of bytes readable */
4586 BOOL error = FALSE; /* Error holder */
4587 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */
4589 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4590 return FALSE;
4591 }
4593 /* Construct an array of input records in the console buffer */
4594 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4595 if (error == 0) {
4596 return nonSeekAvailable(fd, pbytes);
4597 }
4599 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4600 if (numEvents > MAX_INPUT_EVENTS) {
4601 numEvents = MAX_INPUT_EVENTS;
4602 }
4604 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4605 if (lpBuffer == NULL) {
4606 return FALSE;
4607 }
4609 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4610 if (error == 0) {
4611 os::free(lpBuffer, mtInternal);
4612 return FALSE;
4613 }
4615 /* Examine input records for the number of bytes available */
4616 for(i=0; i<numEvents; i++) {
4617 if (lpBuffer[i].EventType == KEY_EVENT) {
4619 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4620 &(lpBuffer[i].Event);
4621 if (keyRecord->bKeyDown == TRUE) {
4622 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4623 curLength++;
4624 if (*keyPressed == '\r') {
4625 actualLength = curLength;
4626 }
4627 }
4628 }
4629 }
4631 if(lpBuffer != NULL) {
4632 os::free(lpBuffer, mtInternal);
4633 }
4635 *pbytes = (long) actualLength;
4636 return TRUE;
4637 }
4639 // Map a block of memory.
4640 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4641 char *addr, size_t bytes, bool read_only,
4642 bool allow_exec) {
4643 HANDLE hFile;
4644 char* base;
4646 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4647 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4648 if (hFile == NULL) {
4649 if (PrintMiscellaneous && Verbose) {
4650 DWORD err = GetLastError();
4651 tty->print_cr("CreateFile() failed: GetLastError->%ld.", err);
4652 }
4653 return NULL;
4654 }
4656 if (allow_exec) {
4657 // CreateFileMapping/MapViewOfFileEx can't map executable memory
4658 // unless it comes from a PE image (which the shared archive is not.)
4659 // Even VirtualProtect refuses to give execute access to mapped memory
4660 // that was not previously executable.
4661 //
4662 // Instead, stick the executable region in anonymous memory. Yuck.
4663 // Penalty is that ~4 pages will not be shareable - in the future
4664 // we might consider DLLizing the shared archive with a proper PE
4665 // header so that mapping executable + sharing is possible.
4667 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4668 PAGE_READWRITE);
4669 if (base == NULL) {
4670 if (PrintMiscellaneous && Verbose) {
4671 DWORD err = GetLastError();
4672 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4673 }
4674 CloseHandle(hFile);
4675 return NULL;
4676 }
4678 DWORD bytes_read;
4679 OVERLAPPED overlapped;
4680 overlapped.Offset = (DWORD)file_offset;
4681 overlapped.OffsetHigh = 0;
4682 overlapped.hEvent = NULL;
4683 // ReadFile guarantees that if the return value is true, the requested
4684 // number of bytes were read before returning.
4685 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4686 if (!res) {
4687 if (PrintMiscellaneous && Verbose) {
4688 DWORD err = GetLastError();
4689 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4690 }
4691 release_memory(base, bytes);
4692 CloseHandle(hFile);
4693 return NULL;
4694 }
4695 } else {
4696 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4697 NULL /*file_name*/);
4698 if (hMap == NULL) {
4699 if (PrintMiscellaneous && Verbose) {
4700 DWORD err = GetLastError();
4701 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err);
4702 }
4703 CloseHandle(hFile);
4704 return NULL;
4705 }
4707 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4708 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4709 (DWORD)bytes, addr);
4710 if (base == NULL) {
4711 if (PrintMiscellaneous && Verbose) {
4712 DWORD err = GetLastError();
4713 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4714 }
4715 CloseHandle(hMap);
4716 CloseHandle(hFile);
4717 return NULL;
4718 }
4720 if (CloseHandle(hMap) == 0) {
4721 if (PrintMiscellaneous && Verbose) {
4722 DWORD err = GetLastError();
4723 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4724 }
4725 CloseHandle(hFile);
4726 return base;
4727 }
4728 }
4730 if (allow_exec) {
4731 DWORD old_protect;
4732 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4733 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4735 if (!res) {
4736 if (PrintMiscellaneous && Verbose) {
4737 DWORD err = GetLastError();
4738 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4739 }
4740 // Don't consider this a hard error, on IA32 even if the
4741 // VirtualProtect fails, we should still be able to execute
4742 CloseHandle(hFile);
4743 return base;
4744 }
4745 }
4747 if (CloseHandle(hFile) == 0) {
4748 if (PrintMiscellaneous && Verbose) {
4749 DWORD err = GetLastError();
4750 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4751 }
4752 return base;
4753 }
4755 return base;
4756 }
4759 // Remap a block of memory.
4760 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4761 char *addr, size_t bytes, bool read_only,
4762 bool allow_exec) {
4763 // This OS does not allow existing memory maps to be remapped so we
4764 // have to unmap the memory before we remap it.
4765 if (!os::unmap_memory(addr, bytes)) {
4766 return NULL;
4767 }
4769 // There is a very small theoretical window between the unmap_memory()
4770 // call above and the map_memory() call below where a thread in native
4771 // code may be able to access an address that is no longer mapped.
4773 return os::map_memory(fd, file_name, file_offset, addr, bytes,
4774 read_only, allow_exec);
4775 }
4778 // Unmap a block of memory.
4779 // Returns true=success, otherwise false.
4781 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4782 BOOL result = UnmapViewOfFile(addr);
4783 if (result == 0) {
4784 if (PrintMiscellaneous && Verbose) {
4785 DWORD err = GetLastError();
4786 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4787 }
4788 return false;
4789 }
4790 return true;
4791 }
4793 void os::pause() {
4794 char filename[MAX_PATH];
4795 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4796 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4797 } else {
4798 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4799 }
4801 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4802 if (fd != -1) {
4803 struct stat buf;
4804 ::close(fd);
4805 while (::stat(filename, &buf) == 0) {
4806 Sleep(100);
4807 }
4808 } else {
4809 jio_fprintf(stderr,
4810 "Could not open pause file '%s', continuing immediately.\n", filename);
4811 }
4812 }
4814 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
4815 assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
4816 }
4818 /*
4819 * See the caveats for this class in os_windows.hpp
4820 * Protects the callback call so that raised OS EXCEPTIONS causes a jump back
4821 * into this method and returns false. If no OS EXCEPTION was raised, returns
4822 * true.
4823 * The callback is supposed to provide the method that should be protected.
4824 */
4825 bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
4826 assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
4827 assert(!WatcherThread::watcher_thread()->has_crash_protection(),
4828 "crash_protection already set?");
4830 bool success = true;
4831 __try {
4832 WatcherThread::watcher_thread()->set_crash_protection(this);
4833 cb.call();
4834 } __except(EXCEPTION_EXECUTE_HANDLER) {
4835 // only for protection, nothing to do
4836 success = false;
4837 }
4838 WatcherThread::watcher_thread()->set_crash_protection(NULL);
4839 return success;
4840 }
4842 // An Event wraps a win32 "CreateEvent" kernel handle.
4843 //
4844 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4845 //
4846 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4847 // field, and call CloseHandle() on the win32 event handle. Unpark() would
4848 // need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4849 // In addition, an unpark() operation might fetch the handle field, but the
4850 // event could recycle between the fetch and the SetEvent() operation.
4851 // SetEvent() would either fail because the handle was invalid, or inadvertently work,
4852 // as the win32 handle value had been recycled. In an ideal world calling SetEvent()
4853 // on an stale but recycled handle would be harmless, but in practice this might
4854 // confuse other non-Sun code, so it's not a viable approach.
4855 //
4856 // 2: Once a win32 event handle is associated with an Event, it remains associated
4857 // with the Event. The event handle is never closed. This could be construed
4858 // as handle leakage, but only up to the maximum # of threads that have been extant
4859 // at any one time. This shouldn't be an issue, as windows platforms typically
4860 // permit a process to have hundreds of thousands of open handles.
4861 //
4862 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4863 // and release unused handles.
4864 //
4865 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4866 // It's not clear, however, that we wouldn't be trading one type of leak for another.
4867 //
4868 // 5. Use an RCU-like mechanism (Read-Copy Update).
4869 // Or perhaps something similar to Maged Michael's "Hazard pointers".
4870 //
4871 // We use (2).
4872 //
4873 // TODO-FIXME:
4874 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4875 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4876 // to recover from (or at least detect) the dreaded Windows 841176 bug.
4877 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4878 // into a single win32 CreateEvent() handle.
4879 //
4880 // _Event transitions in park()
4881 // -1 => -1 : illegal
4882 // 1 => 0 : pass - return immediately
4883 // 0 => -1 : block
4884 //
4885 // _Event serves as a restricted-range semaphore :
4886 // -1 : thread is blocked
4887 // 0 : neutral - thread is running or ready
4888 // 1 : signaled - thread is running or ready
4889 //
4890 // Another possible encoding of _Event would be
4891 // with explicit "PARKED" and "SIGNALED" bits.
4893 int os::PlatformEvent::park (jlong Millis) {
4894 guarantee (_ParkHandle != NULL , "Invariant") ;
4895 guarantee (Millis > 0 , "Invariant") ;
4896 int v ;
4898 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4899 // the initial park() operation.
4901 for (;;) {
4902 v = _Event ;
4903 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4904 }
4905 guarantee ((v == 0) || (v == 1), "invariant") ;
4906 if (v != 0) return OS_OK ;
4908 // Do this the hard way by blocking ...
4909 // TODO: consider a brief spin here, gated on the success of recent
4910 // spin attempts by this thread.
4911 //
4912 // We decompose long timeouts into series of shorter timed waits.
4913 // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4914 // versions of Windows. See EventWait() for details. This may be superstition. Or not.
4915 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4916 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from
4917 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4918 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv ==
4919 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4920 // for the already waited time. This policy does not admit any new outcomes.
4921 // In the future, however, we might want to track the accumulated wait time and
4922 // adjust Millis accordingly if we encounter a spurious wakeup.
4924 const int MAXTIMEOUT = 0x10000000 ;
4925 DWORD rv = WAIT_TIMEOUT ;
4926 while (_Event < 0 && Millis > 0) {
4927 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT)
4928 if (Millis > MAXTIMEOUT) {
4929 prd = MAXTIMEOUT ;
4930 }
4931 rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4932 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4933 if (rv == WAIT_TIMEOUT) {
4934 Millis -= prd ;
4935 }
4936 }
4937 v = _Event ;
4938 _Event = 0 ;
4939 // see comment at end of os::PlatformEvent::park() below:
4940 OrderAccess::fence() ;
4941 // If we encounter a nearly simultanous timeout expiry and unpark()
4942 // we return OS_OK indicating we awoke via unpark().
4943 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4944 return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4945 }
4947 void os::PlatformEvent::park () {
4948 guarantee (_ParkHandle != NULL, "Invariant") ;
4949 // Invariant: Only the thread associated with the Event/PlatformEvent
4950 // may call park().
4951 int v ;
4952 for (;;) {
4953 v = _Event ;
4954 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4955 }
4956 guarantee ((v == 0) || (v == 1), "invariant") ;
4957 if (v != 0) return ;
4959 // Do this the hard way by blocking ...
4960 // TODO: consider a brief spin here, gated on the success of recent
4961 // spin attempts by this thread.
4962 while (_Event < 0) {
4963 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4964 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4965 }
4967 // Usually we'll find _Event == 0 at this point, but as
4968 // an optional optimization we clear it, just in case can
4969 // multiple unpark() operations drove _Event up to 1.
4970 _Event = 0 ;
4971 OrderAccess::fence() ;
4972 guarantee (_Event >= 0, "invariant") ;
4973 }
4975 void os::PlatformEvent::unpark() {
4976 guarantee (_ParkHandle != NULL, "Invariant") ;
4978 // Transitions for _Event:
4979 // 0 :=> 1
4980 // 1 :=> 1
4981 // -1 :=> either 0 or 1; must signal target thread
4982 // That is, we can safely transition _Event from -1 to either
4983 // 0 or 1. Forcing 1 is slightly more efficient for back-to-back
4984 // unpark() calls.
4985 // See also: "Semaphores in Plan 9" by Mullender & Cox
4986 //
4987 // Note: Forcing a transition from "-1" to "1" on an unpark() means
4988 // that it will take two back-to-back park() calls for the owning
4989 // thread to block. This has the benefit of forcing a spurious return
4990 // from the first park() call after an unpark() call which will help
4991 // shake out uses of park() and unpark() without condition variables.
4993 if (Atomic::xchg(1, &_Event) >= 0) return;
4995 ::SetEvent(_ParkHandle);
4996 }
4999 // JSR166
5000 // -------------------------------------------------------
5002 /*
5003 * The Windows implementation of Park is very straightforward: Basic
5004 * operations on Win32 Events turn out to have the right semantics to
5005 * use them directly. We opportunistically resuse the event inherited
5006 * from Monitor.
5007 */
5010 void Parker::park(bool isAbsolute, jlong time) {
5011 guarantee (_ParkEvent != NULL, "invariant") ;
5012 // First, demultiplex/decode time arguments
5013 if (time < 0) { // don't wait
5014 return;
5015 }
5016 else if (time == 0 && !isAbsolute) {
5017 time = INFINITE;
5018 }
5019 else if (isAbsolute) {
5020 time -= os::javaTimeMillis(); // convert to relative time
5021 if (time <= 0) // already elapsed
5022 return;
5023 }
5024 else { // relative
5025 time /= 1000000; // Must coarsen from nanos to millis
5026 if (time == 0) // Wait for the minimal time unit if zero
5027 time = 1;
5028 }
5030 JavaThread* thread = (JavaThread*)(Thread::current());
5031 assert(thread->is_Java_thread(), "Must be JavaThread");
5032 JavaThread *jt = (JavaThread *)thread;
5034 // Don't wait if interrupted or already triggered
5035 if (Thread::is_interrupted(thread, false) ||
5036 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
5037 ResetEvent(_ParkEvent);
5038 return;
5039 }
5040 else {
5041 ThreadBlockInVM tbivm(jt);
5042 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5043 jt->set_suspend_equivalent();
5045 WaitForSingleObject(_ParkEvent, time);
5046 ResetEvent(_ParkEvent);
5048 // If externally suspended while waiting, re-suspend
5049 if (jt->handle_special_suspend_equivalent_condition()) {
5050 jt->java_suspend_self();
5051 }
5052 }
5053 }
5055 void Parker::unpark() {
5056 guarantee (_ParkEvent != NULL, "invariant") ;
5057 SetEvent(_ParkEvent);
5058 }
5060 // Run the specified command in a separate process. Return its exit value,
5061 // or -1 on failure (e.g. can't create a new process).
5062 int os::fork_and_exec(char* cmd, bool use_vfork_if_available) {
5063 STARTUPINFO si;
5064 PROCESS_INFORMATION pi;
5066 memset(&si, 0, sizeof(si));
5067 si.cb = sizeof(si);
5068 memset(&pi, 0, sizeof(pi));
5069 BOOL rslt = CreateProcess(NULL, // executable name - use command line
5070 cmd, // command line
5071 NULL, // process security attribute
5072 NULL, // thread security attribute
5073 TRUE, // inherits system handles
5074 0, // no creation flags
5075 NULL, // use parent's environment block
5076 NULL, // use parent's starting directory
5077 &si, // (in) startup information
5078 &pi); // (out) process information
5080 if (rslt) {
5081 // Wait until child process exits.
5082 WaitForSingleObject(pi.hProcess, INFINITE);
5084 DWORD exit_code;
5085 GetExitCodeProcess(pi.hProcess, &exit_code);
5087 // Close process and thread handles.
5088 CloseHandle(pi.hProcess);
5089 CloseHandle(pi.hThread);
5091 return (int)exit_code;
5092 } else {
5093 return -1;
5094 }
5095 }
5097 //--------------------------------------------------------------------------------------------------
5098 // Non-product code
5100 static int mallocDebugIntervalCounter = 0;
5101 static int mallocDebugCounter = 0;
5102 bool os::check_heap(bool force) {
5103 if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
5104 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
5105 // Note: HeapValidate executes two hardware breakpoints when it finds something
5106 // wrong; at these points, eax contains the address of the offending block (I think).
5107 // To get to the exlicit error message(s) below, just continue twice.
5108 HANDLE heap = GetProcessHeap();
5109 { HeapLock(heap);
5110 PROCESS_HEAP_ENTRY phe;
5111 phe.lpData = NULL;
5112 while (HeapWalk(heap, &phe) != 0) {
5113 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
5114 !HeapValidate(heap, 0, phe.lpData)) {
5115 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
5116 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
5117 fatal("corrupted C heap");
5118 }
5119 }
5120 DWORD err = GetLastError();
5121 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
5122 fatal(err_msg("heap walk aborted with error %d", err));
5123 }
5124 HeapUnlock(heap);
5125 }
5126 mallocDebugIntervalCounter = 0;
5127 }
5128 return true;
5129 }
5132 bool os::find(address addr, outputStream* st) {
5133 // Nothing yet
5134 return false;
5135 }
5137 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5138 DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5140 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
5141 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
5142 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5143 address addr = (address) exceptionRecord->ExceptionInformation[1];
5145 if (os::is_memory_serialize_page(thread, addr))
5146 return EXCEPTION_CONTINUE_EXECUTION;
5147 }
5149 return EXCEPTION_CONTINUE_SEARCH;
5150 }
5152 // We don't build a headless jre for Windows
5153 bool os::is_headless_jre() { return false; }
5155 static jint initSock() {
5156 WSADATA wsadata;
5158 if (!os::WinSock2Dll::WinSock2Available()) {
5159 jio_fprintf(stderr, "Could not load Winsock (error: %d)\n",
5160 ::GetLastError());
5161 return JNI_ERR;
5162 }
5164 if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5165 jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5166 ::GetLastError());
5167 return JNI_ERR;
5168 }
5169 return JNI_OK;
5170 }
5172 struct hostent* os::get_host_by_name(char* name) {
5173 return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
5174 }
5176 int os::socket_close(int fd) {
5177 return ::closesocket(fd);
5178 }
5180 int os::socket_available(int fd, jint *pbytes) {
5181 int ret = ::ioctlsocket(fd, FIONREAD, (u_long*)pbytes);
5182 return (ret < 0) ? 0 : 1;
5183 }
5185 int os::socket(int domain, int type, int protocol) {
5186 return ::socket(domain, type, protocol);
5187 }
5189 int os::listen(int fd, int count) {
5190 return ::listen(fd, count);
5191 }
5193 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5194 return ::connect(fd, him, len);
5195 }
5197 int os::accept(int fd, struct sockaddr* him, socklen_t* len) {
5198 return ::accept(fd, him, len);
5199 }
5201 int os::sendto(int fd, char* buf, size_t len, uint flags,
5202 struct sockaddr* to, socklen_t tolen) {
5204 return ::sendto(fd, buf, (int)len, flags, to, tolen);
5205 }
5207 int os::recvfrom(int fd, char *buf, size_t nBytes, uint flags,
5208 sockaddr* from, socklen_t* fromlen) {
5210 return ::recvfrom(fd, buf, (int)nBytes, flags, from, fromlen);
5211 }
5213 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5214 return ::recv(fd, buf, (int)nBytes, flags);
5215 }
5217 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5218 return ::send(fd, buf, (int)nBytes, flags);
5219 }
5221 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5222 return ::send(fd, buf, (int)nBytes, flags);
5223 }
5225 int os::timeout(int fd, long timeout) {
5226 fd_set tbl;
5227 struct timeval t;
5229 t.tv_sec = timeout / 1000;
5230 t.tv_usec = (timeout % 1000) * 1000;
5232 tbl.fd_count = 1;
5233 tbl.fd_array[0] = fd;
5235 return ::select(1, &tbl, 0, 0, &t);
5236 }
5238 int os::get_host_name(char* name, int namelen) {
5239 return ::gethostname(name, namelen);
5240 }
5242 int os::socket_shutdown(int fd, int howto) {
5243 return ::shutdown(fd, howto);
5244 }
5246 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
5247 return ::bind(fd, him, len);
5248 }
5250 int os::get_sock_name(int fd, struct sockaddr* him, socklen_t* len) {
5251 return ::getsockname(fd, him, len);
5252 }
5254 int os::get_sock_opt(int fd, int level, int optname,
5255 char* optval, socklen_t* optlen) {
5256 return ::getsockopt(fd, level, optname, optval, optlen);
5257 }
5259 int os::set_sock_opt(int fd, int level, int optname,
5260 const char* optval, socklen_t optlen) {
5261 return ::setsockopt(fd, level, optname, optval, optlen);
5262 }
5264 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5265 #if defined(IA32)
5266 # define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5267 #elif defined (AMD64)
5268 # define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5269 #endif
5271 // returns true if thread could be suspended,
5272 // false otherwise
5273 static bool do_suspend(HANDLE* h) {
5274 if (h != NULL) {
5275 if (SuspendThread(*h) != ~0) {
5276 return true;
5277 }
5278 }
5279 return false;
5280 }
5282 // resume the thread
5283 // calling resume on an active thread is a no-op
5284 static void do_resume(HANDLE* h) {
5285 if (h != NULL) {
5286 ResumeThread(*h);
5287 }
5288 }
5290 // retrieve a suspend/resume context capable handle
5291 // from the tid. Caller validates handle return value.
5292 void get_thread_handle_for_extended_context(HANDLE* h, OSThread::thread_id_t tid) {
5293 if (h != NULL) {
5294 *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5295 }
5296 }
5298 //
5299 // Thread sampling implementation
5300 //
5301 void os::SuspendedThreadTask::internal_do_task() {
5302 CONTEXT ctxt;
5303 HANDLE h = NULL;
5305 // get context capable handle for thread
5306 get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5308 // sanity
5309 if (h == NULL || h == INVALID_HANDLE_VALUE) {
5310 return;
5311 }
5313 // suspend the thread
5314 if (do_suspend(&h)) {
5315 ctxt.ContextFlags = sampling_context_flags;
5316 // get thread context
5317 GetThreadContext(h, &ctxt);
5318 SuspendedThreadTaskContext context(_thread, &ctxt);
5319 // pass context to Thread Sampling impl
5320 do_task(context);
5321 // resume thread
5322 do_resume(&h);
5323 }
5325 // close handle
5326 CloseHandle(h);
5327 }
5330 // Kernel32 API
5331 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
5332 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
5333 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
5334 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
5335 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
5337 GetLargePageMinimum_Fn os::Kernel32Dll::_GetLargePageMinimum = NULL;
5338 VirtualAllocExNuma_Fn os::Kernel32Dll::_VirtualAllocExNuma = NULL;
5339 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
5340 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
5341 RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL;
5344 BOOL os::Kernel32Dll::initialized = FALSE;
5345 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
5346 assert(initialized && _GetLargePageMinimum != NULL,
5347 "GetLargePageMinimumAvailable() not yet called");
5348 return _GetLargePageMinimum();
5349 }
5351 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
5352 if (!initialized) {
5353 initialize();
5354 }
5355 return _GetLargePageMinimum != NULL;
5356 }
5358 BOOL os::Kernel32Dll::NumaCallsAvailable() {
5359 if (!initialized) {
5360 initialize();
5361 }
5362 return _VirtualAllocExNuma != NULL;
5363 }
5365 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
5366 assert(initialized && _VirtualAllocExNuma != NULL,
5367 "NUMACallsAvailable() not yet called");
5369 return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
5370 }
5372 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
5373 assert(initialized && _GetNumaHighestNodeNumber != NULL,
5374 "NUMACallsAvailable() not yet called");
5376 return _GetNumaHighestNodeNumber(ptr_highest_node_number);
5377 }
5379 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
5380 assert(initialized && _GetNumaNodeProcessorMask != NULL,
5381 "NUMACallsAvailable() not yet called");
5383 return _GetNumaNodeProcessorMask(node, proc_mask);
5384 }
5386 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
5387 ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) {
5388 if (!initialized) {
5389 initialize();
5390 }
5392 if (_RtlCaptureStackBackTrace != NULL) {
5393 return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture,
5394 BackTrace, BackTraceHash);
5395 } else {
5396 return 0;
5397 }
5398 }
5400 void os::Kernel32Dll::initializeCommon() {
5401 if (!initialized) {
5402 HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5403 assert(handle != NULL, "Just check");
5404 _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
5405 _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
5406 _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
5407 _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
5408 _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace");
5409 initialized = TRUE;
5410 }
5411 }
5415 #ifndef JDK6_OR_EARLIER
5417 void os::Kernel32Dll::initialize() {
5418 initializeCommon();
5419 }
5422 // Kernel32 API
5423 inline BOOL os::Kernel32Dll::SwitchToThread() {
5424 return ::SwitchToThread();
5425 }
5427 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5428 return true;
5429 }
5431 // Help tools
5432 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5433 return true;
5434 }
5436 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5437 return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5438 }
5440 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5441 return ::Module32First(hSnapshot, lpme);
5442 }
5444 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5445 return ::Module32Next(hSnapshot, lpme);
5446 }
5448 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5449 ::GetNativeSystemInfo(lpSystemInfo);
5450 }
5452 // PSAPI API
5453 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5454 return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5455 }
5457 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5458 return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5459 }
5461 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5462 return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5463 }
5465 inline BOOL os::PSApiDll::PSApiAvailable() {
5466 return true;
5467 }
5470 // WinSock2 API
5471 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5472 return ::WSAStartup(wVersionRequested, lpWSAData);
5473 }
5475 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5476 return ::gethostbyname(name);
5477 }
5479 inline BOOL os::WinSock2Dll::WinSock2Available() {
5480 return true;
5481 }
5483 // Advapi API
5484 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5485 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5486 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5487 return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5488 BufferLength, PreviousState, ReturnLength);
5489 }
5491 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5492 PHANDLE TokenHandle) {
5493 return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5494 }
5496 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5497 return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5498 }
5500 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5501 return true;
5502 }
5504 void* os::get_default_process_handle() {
5505 return (void*)GetModuleHandle(NULL);
5506 }
5508 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
5509 // which is used to find statically linked in agents.
5510 // Additionally for windows, takes into account __stdcall names.
5511 // Parameters:
5512 // sym_name: Symbol in library we are looking for
5513 // lib_name: Name of library to look in, NULL for shared libs.
5514 // is_absolute_path == true if lib_name is absolute path to agent
5515 // such as "C:/a/b/L.dll"
5516 // == false if only the base name of the library is passed in
5517 // such as "L"
5518 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
5519 bool is_absolute_path) {
5520 char *agent_entry_name;
5521 size_t len;
5522 size_t name_len;
5523 size_t prefix_len = strlen(JNI_LIB_PREFIX);
5524 size_t suffix_len = strlen(JNI_LIB_SUFFIX);
5525 const char *start;
5527 if (lib_name != NULL) {
5528 len = name_len = strlen(lib_name);
5529 if (is_absolute_path) {
5530 // Need to strip path, prefix and suffix
5531 if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
5532 lib_name = ++start;
5533 } else {
5534 // Need to check for drive prefix
5535 if ((start = strchr(lib_name, ':')) != NULL) {
5536 lib_name = ++start;
5537 }
5538 }
5539 if (len <= (prefix_len + suffix_len)) {
5540 return NULL;
5541 }
5542 lib_name += prefix_len;
5543 name_len = strlen(lib_name) - suffix_len;
5544 }
5545 }
5546 len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
5547 agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
5548 if (agent_entry_name == NULL) {
5549 return NULL;
5550 }
5551 if (lib_name != NULL) {
5552 const char *p = strrchr(sym_name, '@');
5553 if (p != NULL && p != sym_name) {
5554 // sym_name == _Agent_OnLoad@XX
5555 strncpy(agent_entry_name, sym_name, (p - sym_name));
5556 agent_entry_name[(p-sym_name)] = '\0';
5557 // agent_entry_name == _Agent_OnLoad
5558 strcat(agent_entry_name, "_");
5559 strncat(agent_entry_name, lib_name, name_len);
5560 strcat(agent_entry_name, p);
5561 // agent_entry_name == _Agent_OnLoad_lib_name@XX
5562 } else {
5563 strcpy(agent_entry_name, sym_name);
5564 strcat(agent_entry_name, "_");
5565 strncat(agent_entry_name, lib_name, name_len);
5566 }
5567 } else {
5568 strcpy(agent_entry_name, sym_name);
5569 }
5570 return agent_entry_name;
5571 }
5573 #else
5574 // Kernel32 API
5575 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5576 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5577 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5578 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5579 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5581 SwitchToThread_Fn os::Kernel32Dll::_SwitchToThread = NULL;
5582 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5583 Module32First_Fn os::Kernel32Dll::_Module32First = NULL;
5584 Module32Next_Fn os::Kernel32Dll::_Module32Next = NULL;
5585 GetNativeSystemInfo_Fn os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5587 void os::Kernel32Dll::initialize() {
5588 if (!initialized) {
5589 HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5590 assert(handle != NULL, "Just check");
5592 _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5593 _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5594 ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5595 _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5596 _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5597 _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5598 initializeCommon(); // resolve the functions that always need resolving
5600 initialized = TRUE;
5601 }
5602 }
5604 BOOL os::Kernel32Dll::SwitchToThread() {
5605 assert(initialized && _SwitchToThread != NULL,
5606 "SwitchToThreadAvailable() not yet called");
5607 return _SwitchToThread();
5608 }
5611 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5612 if (!initialized) {
5613 initialize();
5614 }
5615 return _SwitchToThread != NULL;
5616 }
5618 // Help tools
5619 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5620 if (!initialized) {
5621 initialize();
5622 }
5623 return _CreateToolhelp32Snapshot != NULL &&
5624 _Module32First != NULL &&
5625 _Module32Next != NULL;
5626 }
5628 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5629 assert(initialized && _CreateToolhelp32Snapshot != NULL,
5630 "HelpToolsAvailable() not yet called");
5632 return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5633 }
5635 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5636 assert(initialized && _Module32First != NULL,
5637 "HelpToolsAvailable() not yet called");
5639 return _Module32First(hSnapshot, lpme);
5640 }
5642 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5643 assert(initialized && _Module32Next != NULL,
5644 "HelpToolsAvailable() not yet called");
5646 return _Module32Next(hSnapshot, lpme);
5647 }
5650 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5651 if (!initialized) {
5652 initialize();
5653 }
5654 return _GetNativeSystemInfo != NULL;
5655 }
5657 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5658 assert(initialized && _GetNativeSystemInfo != NULL,
5659 "GetNativeSystemInfoAvailable() not yet called");
5661 _GetNativeSystemInfo(lpSystemInfo);
5662 }
5664 // PSAPI API
5667 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5668 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5669 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5671 EnumProcessModules_Fn os::PSApiDll::_EnumProcessModules = NULL;
5672 GetModuleFileNameEx_Fn os::PSApiDll::_GetModuleFileNameEx = NULL;
5673 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5674 BOOL os::PSApiDll::initialized = FALSE;
5676 void os::PSApiDll::initialize() {
5677 if (!initialized) {
5678 HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5679 if (handle != NULL) {
5680 _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5681 "EnumProcessModules");
5682 _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5683 "GetModuleFileNameExA");
5684 _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5685 "GetModuleInformation");
5686 }
5687 initialized = TRUE;
5688 }
5689 }
5693 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5694 assert(initialized && _EnumProcessModules != NULL,
5695 "PSApiAvailable() not yet called");
5696 return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5697 }
5699 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5700 assert(initialized && _GetModuleFileNameEx != NULL,
5701 "PSApiAvailable() not yet called");
5702 return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5703 }
5705 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5706 assert(initialized && _GetModuleInformation != NULL,
5707 "PSApiAvailable() not yet called");
5708 return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5709 }
5711 BOOL os::PSApiDll::PSApiAvailable() {
5712 if (!initialized) {
5713 initialize();
5714 }
5715 return _EnumProcessModules != NULL &&
5716 _GetModuleFileNameEx != NULL &&
5717 _GetModuleInformation != NULL;
5718 }
5721 // WinSock2 API
5722 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5723 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5725 WSAStartup_Fn os::WinSock2Dll::_WSAStartup = NULL;
5726 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5727 BOOL os::WinSock2Dll::initialized = FALSE;
5729 void os::WinSock2Dll::initialize() {
5730 if (!initialized) {
5731 HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5732 if (handle != NULL) {
5733 _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5734 _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5735 }
5736 initialized = TRUE;
5737 }
5738 }
5741 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5742 assert(initialized && _WSAStartup != NULL,
5743 "WinSock2Available() not yet called");
5744 return _WSAStartup(wVersionRequested, lpWSAData);
5745 }
5747 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5748 assert(initialized && _gethostbyname != NULL,
5749 "WinSock2Available() not yet called");
5750 return _gethostbyname(name);
5751 }
5753 BOOL os::WinSock2Dll::WinSock2Available() {
5754 if (!initialized) {
5755 initialize();
5756 }
5757 return _WSAStartup != NULL &&
5758 _gethostbyname != NULL;
5759 }
5761 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5762 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5763 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5765 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5766 OpenProcessToken_Fn os::Advapi32Dll::_OpenProcessToken = NULL;
5767 LookupPrivilegeValue_Fn os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5768 BOOL os::Advapi32Dll::initialized = FALSE;
5770 void os::Advapi32Dll::initialize() {
5771 if (!initialized) {
5772 HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5773 if (handle != NULL) {
5774 _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5775 "AdjustTokenPrivileges");
5776 _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5777 "OpenProcessToken");
5778 _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5779 "LookupPrivilegeValueA");
5780 }
5781 initialized = TRUE;
5782 }
5783 }
5785 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5786 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5787 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5788 assert(initialized && _AdjustTokenPrivileges != NULL,
5789 "AdvapiAvailable() not yet called");
5790 return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5791 BufferLength, PreviousState, ReturnLength);
5792 }
5794 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5795 PHANDLE TokenHandle) {
5796 assert(initialized && _OpenProcessToken != NULL,
5797 "AdvapiAvailable() not yet called");
5798 return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5799 }
5801 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5802 assert(initialized && _LookupPrivilegeValue != NULL,
5803 "AdvapiAvailable() not yet called");
5804 return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5805 }
5807 BOOL os::Advapi32Dll::AdvapiAvailable() {
5808 if (!initialized) {
5809 initialize();
5810 }
5811 return _AdjustTokenPrivileges != NULL &&
5812 _OpenProcessToken != NULL &&
5813 _LookupPrivilegeValue != NULL;
5814 }
5816 #endif
5818 #ifndef PRODUCT
5820 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5821 // contiguous memory block at a particular address.
5822 // The test first tries to find a good approximate address to allocate at by using the same
5823 // method to allocate some memory at any address. The test then tries to allocate memory in
5824 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5825 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5826 // the previously allocated memory is available for allocation. The only actual failure
5827 // that is reported is when the test tries to allocate at a particular location but gets a
5828 // different valid one. A NULL return value at this point is not considered an error but may
5829 // be legitimate.
5830 // If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages.
5831 void TestReserveMemorySpecial_test() {
5832 if (!UseLargePages) {
5833 if (VerboseInternalVMTests) {
5834 gclog_or_tty->print("Skipping test because large pages are disabled");
5835 }
5836 return;
5837 }
5838 // save current value of globals
5839 bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5840 bool old_use_numa_interleaving = UseNUMAInterleaving;
5842 // set globals to make sure we hit the correct code path
5843 UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5845 // do an allocation at an address selected by the OS to get a good one.
5846 const size_t large_allocation_size = os::large_page_size() * 4;
5847 char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5848 if (result == NULL) {
5849 if (VerboseInternalVMTests) {
5850 gclog_or_tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
5851 large_allocation_size);
5852 }
5853 } else {
5854 os::release_memory_special(result, large_allocation_size);
5856 // allocate another page within the recently allocated memory area which seems to be a good location. At least
5857 // we managed to get it once.
5858 const size_t expected_allocation_size = os::large_page_size();
5859 char* expected_location = result + os::large_page_size();
5860 char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5861 if (actual_location == NULL) {
5862 if (VerboseInternalVMTests) {
5863 gclog_or_tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
5864 expected_location, large_allocation_size);
5865 }
5866 } else {
5867 // release memory
5868 os::release_memory_special(actual_location, expected_allocation_size);
5869 // only now check, after releasing any memory to avoid any leaks.
5870 assert(actual_location == expected_location,
5871 err_msg("Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
5872 expected_location, expected_allocation_size, actual_location));
5873 }
5874 }
5876 // restore globals
5877 UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5878 UseNUMAInterleaving = old_use_numa_interleaving;
5879 }
5880 #endif // PRODUCT