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