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