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