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