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