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