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 int os::signal_lookup() {
1968 return check_pending_signals(false);
1969 }
1970
1971 int os::signal_wait() {
1972 return check_pending_signals(true);
1973 }
1974
1975 // Implicit OS exception handling
1976
1977 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
1978 JavaThread* thread = JavaThread::current();
1979 // Save pc in thread
1980 #ifdef _M_IA64
1981 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->StIIP);
1982 // Set pc to handler
1983 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
1984 #elif _M_AMD64
1985 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Rip);
1986 // Set pc to handler
1987 exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
1988 #else
1989 thread->set_saved_exception_pc((address)exceptionInfo->ContextRecord->Eip);
1990 // Set pc to handler
1991 exceptionInfo->ContextRecord->Eip = (LONG)handler;
1992 #endif
1993
1994 // Continue the execution
1995 return EXCEPTION_CONTINUE_EXECUTION;
1996 }
1997
1998
1999 // Used for PostMortemDump
2000 extern "C" void safepoints();
2001 extern "C" void find(int x);
2002 extern "C" void events();
2003
2004 // According to Windows API documentation, an illegal instruction sequence should generate
2005 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2006 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2007 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2008
2009 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2010
2011 // From "Execution Protection in the Windows Operating System" draft 0.35
2012 // Once a system header becomes available, the "real" define should be
2013 // included or copied here.
2014 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2015
2016 #define def_excpt(val) #val, val
2017
2018 struct siglabel {
2019 char *name;
2020 int number;
2021 };
2022
2023 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2024 // C++ compiler contain this error code. Because this is a compiler-generated
2025 // error, the code is not listed in the Win32 API header files.
2026 // The code is actually a cryptic mnemonic device, with the initial "E"
2027 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2028 // ASCII values of "msc".
2029
2030 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363
2031
2032
2033 struct siglabel exceptlabels[] = {
2034 def_excpt(EXCEPTION_ACCESS_VIOLATION),
2035 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2036 def_excpt(EXCEPTION_BREAKPOINT),
2037 def_excpt(EXCEPTION_SINGLE_STEP),
2038 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2039 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2040 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2041 def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2042 def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2043 def_excpt(EXCEPTION_FLT_OVERFLOW),
2044 def_excpt(EXCEPTION_FLT_STACK_CHECK),
2045 def_excpt(EXCEPTION_FLT_UNDERFLOW),
2046 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2047 def_excpt(EXCEPTION_INT_OVERFLOW),
2048 def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2049 def_excpt(EXCEPTION_IN_PAGE_ERROR),
2050 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2051 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2052 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2053 def_excpt(EXCEPTION_STACK_OVERFLOW),
2054 def_excpt(EXCEPTION_INVALID_DISPOSITION),
2055 def_excpt(EXCEPTION_GUARD_PAGE),
2056 def_excpt(EXCEPTION_INVALID_HANDLE),
2057 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2058 NULL, 0
2059 };
2060
2061 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2062 for (int i = 0; exceptlabels[i].name != NULL; i++) {
2063 if (exceptlabels[i].number == exception_code) {
2064 jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2065 return buf;
2066 }
2067 }
2068
2069 return NULL;
2070 }
2071
2072 //-----------------------------------------------------------------------------
2073 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2074 // handle exception caused by idiv; should only happen for -MinInt/-1
2075 // (division by zero is handled explicitly)
2076 #ifdef _M_IA64
2077 assert(0, "Fix Handle_IDiv_Exception");
2078 #elif _M_AMD64
2079 PCONTEXT ctx = exceptionInfo->ContextRecord;
2080 address pc = (address)ctx->Rip;
2081 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2082 assert(pc[0] == 0xF7, "not an idiv opcode");
2083 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2084 assert(ctx->Rax == min_jint, "unexpected idiv exception");
2085 // set correct result values and continue after idiv instruction
2086 ctx->Rip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2087 ctx->Rax = (DWORD)min_jint; // result
2088 ctx->Rdx = (DWORD)0; // remainder
2089 // Continue the execution
2090 #else
2091 PCONTEXT ctx = exceptionInfo->ContextRecord;
2092 address pc = (address)ctx->Eip;
2093 NOT_PRODUCT(Events::log("idiv overflow exception at " INTPTR_FORMAT , pc));
2094 assert(pc[0] == 0xF7, "not an idiv opcode");
2095 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2096 assert(ctx->Eax == min_jint, "unexpected idiv exception");
2097 // set correct result values and continue after idiv instruction
2098 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2099 ctx->Eax = (DWORD)min_jint; // result
2100 ctx->Edx = (DWORD)0; // remainder
2101 // Continue the execution
2102 #endif
2103 return EXCEPTION_CONTINUE_EXECUTION;
2104 }
2105
2106 #ifndef _WIN64
2107 //-----------------------------------------------------------------------------
2108 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2109 // handle exception caused by native method modifying control word
2110 PCONTEXT ctx = exceptionInfo->ContextRecord;
2111 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2112
2113 switch (exception_code) {
2114 case EXCEPTION_FLT_DENORMAL_OPERAND:
2115 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2116 case EXCEPTION_FLT_INEXACT_RESULT:
2117 case EXCEPTION_FLT_INVALID_OPERATION:
2118 case EXCEPTION_FLT_OVERFLOW:
2119 case EXCEPTION_FLT_STACK_CHECK:
2120 case EXCEPTION_FLT_UNDERFLOW:
2121 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2122 if (fp_control_word != ctx->FloatSave.ControlWord) {
2123 // Restore FPCW and mask out FLT exceptions
2124 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2125 // Mask out pending FLT exceptions
2126 ctx->FloatSave.StatusWord &= 0xffffff00;
2127 return EXCEPTION_CONTINUE_EXECUTION;
2128 }
2129 }
2130
2131 if (prev_uef_handler != NULL) {
2132 // We didn't handle this exception so pass it to the previous
2133 // UnhandledExceptionFilter.
2134 return (prev_uef_handler)(exceptionInfo);
2135 }
2136
2137 return EXCEPTION_CONTINUE_SEARCH;
2138 }
2139 #else //_WIN64
2140 /*
2141 On Windows, the mxcsr control bits are non-volatile across calls
2142 See also CR 6192333
2143 If EXCEPTION_FLT_* happened after some native method modified
2144 mxcsr - it is not a jvm fault.
2145 However should we decide to restore of mxcsr after a faulty
2146 native method we can uncomment following code
2147 jint MxCsr = INITIAL_MXCSR;
2148 // we can't use StubRoutines::addr_mxcsr_std()
2149 // because in Win64 mxcsr is not saved there
2150 if (MxCsr != ctx->MxCsr) {
2151 ctx->MxCsr = MxCsr;
2152 return EXCEPTION_CONTINUE_EXECUTION;
2153 }
2154
2155 */
2156 #endif //_WIN64
2157
2158
2159 // Fatal error reporting is single threaded so we can make this a
2160 // static and preallocated. If it's more than MAX_PATH silently ignore
2161 // it.
2162 static char saved_error_file[MAX_PATH] = {0};
2163
2164 void os::set_error_file(const char *logfile) {
2165 if (strlen(logfile) <= MAX_PATH) {
2166 strncpy(saved_error_file, logfile, MAX_PATH);
2167 }
2168 }
2169
2170 static inline void report_error(Thread* t, DWORD exception_code,
2171 address addr, void* siginfo, void* context) {
2172 VMError err(t, exception_code, addr, siginfo, context);
2173 err.report_and_die();
2174
2175 // If UseOsErrorReporting, this will return here and save the error file
2176 // somewhere where we can find it in the minidump.
2177 }
2178
2179 //-----------------------------------------------------------------------------
2180 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2181 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2182 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2183 #ifdef _M_IA64
2184 address pc = (address) exceptionInfo->ContextRecord->StIIP;
2185 #elif _M_AMD64
2186 address pc = (address) exceptionInfo->ContextRecord->Rip;
2187 #else
2188 address pc = (address) exceptionInfo->ContextRecord->Eip;
2189 #endif
2190 Thread* t = ThreadLocalStorage::get_thread_slow(); // slow & steady
2191
2192 #ifndef _WIN64
2193 // Execution protection violation - win32 running on AMD64 only
2194 // Handled first to avoid misdiagnosis as a "normal" access violation;
2195 // This is safe to do because we have a new/unique ExceptionInformation
2196 // code for this condition.
2197 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2198 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2199 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2200 address addr = (address) exceptionRecord->ExceptionInformation[1];
2201
2202 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2203 int page_size = os::vm_page_size();
2204
2205 // Make sure the pc and the faulting address are sane.
2206 //
2207 // If an instruction spans a page boundary, and the page containing
2208 // the beginning of the instruction is executable but the following
2209 // page is not, the pc and the faulting address might be slightly
2210 // different - we still want to unguard the 2nd page in this case.
2211 //
2212 // 15 bytes seems to be a (very) safe value for max instruction size.
2213 bool pc_is_near_addr =
2214 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2215 bool instr_spans_page_boundary =
2216 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2217 (intptr_t) page_size) > 0);
2218
2219 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2220 static volatile address last_addr =
2221 (address) os::non_memory_address_word();
2222
2223 // In conservative mode, don't unguard unless the address is in the VM
2224 if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2225 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2226
2227 // Set memory to RWX and retry
2228 address page_start =
2229 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2230 bool res = os::protect_memory((char*) page_start, page_size,
2231 os::MEM_PROT_RWX);
2232
2233 if (PrintMiscellaneous && Verbose) {
2234 char buf[256];
2235 jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2236 "at " INTPTR_FORMAT
2237 ", unguarding " INTPTR_FORMAT ": %s", addr,
2238 page_start, (res ? "success" : strerror(errno)));
2239 tty->print_raw_cr(buf);
2240 }
2241
2242 // Set last_addr so if we fault again at the same address, we don't
2243 // end up in an endless loop.
2244 //
2245 // There are two potential complications here. Two threads trapping
2246 // at the same address at the same time could cause one of the
2247 // threads to think it already unguarded, and abort the VM. Likely
2248 // very rare.
2249 //
2250 // The other race involves two threads alternately trapping at
2251 // different addresses and failing to unguard the page, resulting in
2252 // an endless loop. This condition is probably even more unlikely
2253 // than the first.
2254 //
2255 // Although both cases could be avoided by using locks or thread
2256 // local last_addr, these solutions are unnecessary complication:
2257 // this handler is a best-effort safety net, not a complete solution.
2258 // It is disabled by default and should only be used as a workaround
2259 // in case we missed any no-execute-unsafe VM code.
2260
2261 last_addr = addr;
2262
2263 return EXCEPTION_CONTINUE_EXECUTION;
2264 }
2265 }
2266
2267 // Last unguard failed or not unguarding
2268 tty->print_raw_cr("Execution protection violation");
2269 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2270 exceptionInfo->ContextRecord);
2271 return EXCEPTION_CONTINUE_SEARCH;
2272 }
2273 }
2274 #endif // _WIN64
2275
2276 // Check to see if we caught the safepoint code in the
2277 // process of write protecting the memory serialization page.
2278 // It write enables the page immediately after protecting it
2279 // so just return.
2280 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2281 JavaThread* thread = (JavaThread*) t;
2282 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2283 address addr = (address) exceptionRecord->ExceptionInformation[1];
2284 if ( os::is_memory_serialize_page(thread, addr) ) {
2285 // Block current thread until the memory serialize page permission restored.
2286 os::block_on_serialize_page_trap();
2287 return EXCEPTION_CONTINUE_EXECUTION;
2288 }
2289 }
2290
2291 if (t != NULL && t->is_Java_thread()) {
2292 JavaThread* thread = (JavaThread*) t;
2293 bool in_java = thread->thread_state() == _thread_in_Java;
2294
2295 // Handle potential stack overflows up front.
2296 if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2297 if (os::uses_stack_guard_pages()) {
2298 #ifdef _M_IA64
2299 //
2300 // If it's a legal stack address continue, Windows will map it in.
2301 //
2302 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2303 address addr = (address) exceptionRecord->ExceptionInformation[1];
2304 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() )
2305 return EXCEPTION_CONTINUE_EXECUTION;
2306
2307 // The register save area is the same size as the memory stack
2308 // and starts at the page just above the start of the memory stack.
2309 // If we get a fault in this area, we've run out of register
2310 // stack. If we are in java, try throwing a stack overflow exception.
2311 if (addr > thread->stack_base() &&
2312 addr <= (thread->stack_base()+thread->stack_size()) ) {
2313 char buf[256];
2314 jio_snprintf(buf, sizeof(buf),
2315 "Register stack overflow, addr:%p, stack_base:%p\n",
2316 addr, thread->stack_base() );
2317 tty->print_raw_cr(buf);
2318 // If not in java code, return and hope for the best.
2319 return in_java ? Handle_Exception(exceptionInfo,
2320 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2321 : EXCEPTION_CONTINUE_EXECUTION;
2322 }
2323 #endif
2324 if (thread->stack_yellow_zone_enabled()) {
2325 // Yellow zone violation. The o/s has unprotected the first yellow
2326 // zone page for us. Note: must call disable_stack_yellow_zone to
2327 // update the enabled status, even if the zone contains only one page.
2328 thread->disable_stack_yellow_zone();
2329 // If not in java code, return and hope for the best.
2330 return in_java ? Handle_Exception(exceptionInfo,
2331 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2332 : EXCEPTION_CONTINUE_EXECUTION;
2333 } else {
2334 // Fatal red zone violation.
2335 thread->disable_stack_red_zone();
2336 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2337 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2338 exceptionInfo->ContextRecord);
2339 return EXCEPTION_CONTINUE_SEARCH;
2340 }
2341 } else if (in_java) {
2342 // JVM-managed guard pages cannot be used on win95/98. The o/s provides
2343 // a one-time-only guard page, which it has released to us. The next
2344 // stack overflow on this thread will result in an ACCESS_VIOLATION.
2345 return Handle_Exception(exceptionInfo,
2346 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2347 } else {
2348 // Can only return and hope for the best. Further stack growth will
2349 // result in an ACCESS_VIOLATION.
2350 return EXCEPTION_CONTINUE_EXECUTION;
2351 }
2352 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2353 // Either stack overflow or null pointer exception.
2354 if (in_java) {
2355 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2356 address addr = (address) exceptionRecord->ExceptionInformation[1];
2357 address stack_end = thread->stack_base() - thread->stack_size();
2358 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2359 // Stack overflow.
2360 assert(!os::uses_stack_guard_pages(),
2361 "should be caught by red zone code above.");
2362 return Handle_Exception(exceptionInfo,
2363 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2364 }
2365 //
2366 // Check for safepoint polling and implicit null
2367 // We only expect null pointers in the stubs (vtable)
2368 // the rest are checked explicitly now.
2369 //
2370 CodeBlob* cb = CodeCache::find_blob(pc);
2371 if (cb != NULL) {
2372 if (os::is_poll_address(addr)) {
2373 address stub = SharedRuntime::get_poll_stub(pc);
2374 return Handle_Exception(exceptionInfo, stub);
2375 }
2376 }
2377 {
2378 #ifdef _WIN64
2379 //
2380 // If it's a legal stack address map the entire region in
2381 //
2382 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2383 address addr = (address) exceptionRecord->ExceptionInformation[1];
2384 if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2385 addr = (address)((uintptr_t)addr &
2386 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2387 os::commit_memory((char *)addr, thread->stack_base() - addr,
2388 false );
2389 return EXCEPTION_CONTINUE_EXECUTION;
2390 }
2391 else
2392 #endif
2393 {
2394 // Null pointer exception.
2395 #ifdef _M_IA64
2396 // We catch register stack overflows in compiled code by doing
2397 // an explicit compare and executing a st8(G0, G0) if the
2398 // BSP enters into our guard area. We test for the overflow
2399 // condition and fall into the normal null pointer exception
2400 // code if BSP hasn't overflowed.
2401 if ( in_java ) {
2402 if(thread->register_stack_overflow()) {
2403 assert((address)exceptionInfo->ContextRecord->IntS3 ==
2404 thread->register_stack_limit(),
2405 "GR7 doesn't contain register_stack_limit");
2406 // Disable the yellow zone which sets the state that
2407 // we've got a stack overflow problem.
2408 if (thread->stack_yellow_zone_enabled()) {
2409 thread->disable_stack_yellow_zone();
2410 }
2411 // Give us some room to process the exception
2412 thread->disable_register_stack_guard();
2413 // Update GR7 with the new limit so we can continue running
2414 // compiled code.
2415 exceptionInfo->ContextRecord->IntS3 =
2416 (ULONGLONG)thread->register_stack_limit();
2417 return Handle_Exception(exceptionInfo,
2418 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2419 } else {
2420 //
2421 // Check for implicit null
2422 // We only expect null pointers in the stubs (vtable)
2423 // the rest are checked explicitly now.
2424 //
2425 if (((uintptr_t)addr) < os::vm_page_size() ) {
2426 // an access to the first page of VM--assume it is a null pointer
2427 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2428 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2429 }
2430 }
2431 } // in_java
2432
2433 // IA64 doesn't use implicit null checking yet. So we shouldn't
2434 // get here.
2435 tty->print_raw_cr("Access violation, possible null pointer exception");
2436 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2437 exceptionInfo->ContextRecord);
2438 return EXCEPTION_CONTINUE_SEARCH;
2439 #else /* !IA64 */
2440
2441 // Windows 98 reports faulting addresses incorrectly
2442 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2443 !os::win32::is_nt()) {
2444 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2445 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2446 }
2447 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2448 exceptionInfo->ContextRecord);
2449 return EXCEPTION_CONTINUE_SEARCH;
2450 #endif
2451 }
2452 }
2453 }
2454
2455 #ifdef _WIN64
2456 // Special care for fast JNI field accessors.
2457 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2458 // in and the heap gets shrunk before the field access.
2459 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2460 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2461 if (addr != (address)-1) {
2462 return Handle_Exception(exceptionInfo, addr);
2463 }
2464 }
2465 #endif
2466
2467 #ifdef _WIN64
2468 // Windows will sometimes generate an access violation
2469 // when we call malloc. Since we use VectoredExceptions
2470 // on 64 bit platforms, we see this exception. We must
2471 // pass this exception on so Windows can recover.
2472 // We check to see if the pc of the fault is in NTDLL.DLL
2473 // if so, we pass control on to Windows for handling.
2474 if (UseVectoredExceptions && _addr_in_ntdll(pc)) return EXCEPTION_CONTINUE_SEARCH;
2475 #endif
2476
2477 // Stack overflow or null pointer exception in native code.
2478 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2479 exceptionInfo->ContextRecord);
2480 return EXCEPTION_CONTINUE_SEARCH;
2481 }
2482
2483 if (in_java) {
2484 switch (exception_code) {
2485 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2486 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2487
2488 case EXCEPTION_INT_OVERFLOW:
2489 return Handle_IDiv_Exception(exceptionInfo);
2490
2491 } // switch
2492 }
2493 #ifndef _WIN64
2494 if (((thread->thread_state() == _thread_in_Java) ||
2495 (thread->thread_state() == _thread_in_native)) &&
2496 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2497 {
2498 LONG result=Handle_FLT_Exception(exceptionInfo);
2499 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2500 }
2501 #endif //_WIN64
2502 }
2503
2504 if (exception_code != EXCEPTION_BREAKPOINT) {
2505 #ifndef _WIN64
2506 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2507 exceptionInfo->ContextRecord);
2508 #else
2509 // Itanium Windows uses a VectoredExceptionHandler
2510 // Which means that C++ programatic exception handlers (try/except)
2511 // will get here. Continue the search for the right except block if
2512 // the exception code is not a fatal code.
2513 switch ( exception_code ) {
2514 case EXCEPTION_ACCESS_VIOLATION:
2515 case EXCEPTION_STACK_OVERFLOW:
2516 case EXCEPTION_ILLEGAL_INSTRUCTION:
2517 case EXCEPTION_ILLEGAL_INSTRUCTION_2:
2518 case EXCEPTION_INT_OVERFLOW:
2519 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2520 case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
2521 { report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2522 exceptionInfo->ContextRecord);
2523 }
2524 break;
2525 default:
2526 break;
2527 }
2528 #endif
2529 }
2530 return EXCEPTION_CONTINUE_SEARCH;
2531 }
2532
2533 #ifndef _WIN64
2534 // Special care for fast JNI accessors.
2535 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2536 // the heap gets shrunk before the field access.
2537 // Need to install our own structured exception handler since native code may
2538 // install its own.
2539 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2540 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2541 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2542 address pc = (address) exceptionInfo->ContextRecord->Eip;
2543 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2544 if (addr != (address)-1) {
2545 return Handle_Exception(exceptionInfo, addr);
2546 }
2547 }
2548 return EXCEPTION_CONTINUE_SEARCH;
2549 }
2550
2551 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2552 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2553 __try { \
2554 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2555 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2556 } \
2557 return 0; \
2558 }
2559
2560 DEFINE_FAST_GETFIELD(jboolean, bool, Boolean)
2561 DEFINE_FAST_GETFIELD(jbyte, byte, Byte)
2562 DEFINE_FAST_GETFIELD(jchar, char, Char)
2563 DEFINE_FAST_GETFIELD(jshort, short, Short)
2564 DEFINE_FAST_GETFIELD(jint, int, Int)
2565 DEFINE_FAST_GETFIELD(jlong, long, Long)
2566 DEFINE_FAST_GETFIELD(jfloat, float, Float)
2567 DEFINE_FAST_GETFIELD(jdouble, double, Double)
2568
2569 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2570 switch (type) {
2571 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2572 case T_BYTE: return (address)jni_fast_GetByteField_wrapper;
2573 case T_CHAR: return (address)jni_fast_GetCharField_wrapper;
2574 case T_SHORT: return (address)jni_fast_GetShortField_wrapper;
2575 case T_INT: return (address)jni_fast_GetIntField_wrapper;
2576 case T_LONG: return (address)jni_fast_GetLongField_wrapper;
2577 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper;
2578 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper;
2579 default: ShouldNotReachHere();
2580 }
2581 return (address)-1;
2582 }
2583 #endif
2584
2585 // Virtual Memory
2586
2587 int os::vm_page_size() { return os::win32::vm_page_size(); }
2588 int os::vm_allocation_granularity() {
2589 return os::win32::vm_allocation_granularity();
2590 }
2591
2592 // Windows large page support is available on Windows 2003. In order to use
2593 // large page memory, the administrator must first assign additional privilege
2594 // to the user:
2595 // + select Control Panel -> Administrative Tools -> Local Security Policy
2596 // + select Local Policies -> User Rights Assignment
2597 // + double click "Lock pages in memory", add users and/or groups
2598 // + reboot
2599 // Note the above steps are needed for administrator as well, as administrators
2600 // by default do not have the privilege to lock pages in memory.
2601 //
2602 // Note about Windows 2003: although the API supports committing large page
2603 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2604 // scenario, I found through experiment it only uses large page if the entire
2605 // memory region is reserved and committed in a single VirtualAlloc() call.
2606 // This makes Windows large page support more or less like Solaris ISM, in
2607 // that the entire heap must be committed upfront. This probably will change
2608 // in the future, if so the code below needs to be revisited.
2609
2610 #ifndef MEM_LARGE_PAGES
2611 #define MEM_LARGE_PAGES 0x20000000
2612 #endif
2613
2614 static HANDLE _hProcess;
2615 static HANDLE _hToken;
2616
2617 static size_t _large_page_size = 0;
2618
2619 static bool resolve_functions_for_large_page_init() {
2620 return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2621 os::Advapi32Dll::AdvapiAvailable();
2622 }
2623
2624 static bool request_lock_memory_privilege() {
2625 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2626 os::current_process_id());
2627
2628 LUID luid;
2629 if (_hProcess != NULL &&
2630 os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2631 os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2632
2633 TOKEN_PRIVILEGES tp;
2634 tp.PrivilegeCount = 1;
2635 tp.Privileges[0].Luid = luid;
2636 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2637
2638 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2639 // privilege. Check GetLastError() too. See MSDN document.
2640 if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2641 (GetLastError() == ERROR_SUCCESS)) {
2642 return true;
2643 }
2644 }
2645
2646 return false;
2647 }
2648
2649 static void cleanup_after_large_page_init() {
2650 if (_hProcess) CloseHandle(_hProcess);
2651 _hProcess = NULL;
2652 if (_hToken) CloseHandle(_hToken);
2653 _hToken = NULL;
2654 }
2655
2656 void os::large_page_init() {
2657 if (!UseLargePages) return;
2658
2659 // print a warning if any large page related flag is specified on command line
2660 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2661 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2662 bool success = false;
2663
2664 # define WARN(msg) if (warn_on_failure) { warning(msg); }
2665 if (resolve_functions_for_large_page_init()) {
2666 if (request_lock_memory_privilege()) {
2667 size_t s = os::Kernel32Dll::GetLargePageMinimum();
2668 if (s) {
2669 #if defined(IA32) || defined(AMD64)
2670 if (s > 4*M || LargePageSizeInBytes > 4*M) {
2671 WARN("JVM cannot use large pages bigger than 4mb.");
2672 } else {
2673 #endif
2674 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2675 _large_page_size = LargePageSizeInBytes;
2676 } else {
2677 _large_page_size = s;
2678 }
2679 success = true;
2680 #if defined(IA32) || defined(AMD64)
2681 }
2682 #endif
2683 } else {
2684 WARN("Large page is not supported by the processor.");
2685 }
2686 } else {
2687 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2688 }
2689 } else {
2690 WARN("Large page is not supported by the operating system.");
2691 }
2692 #undef WARN
2693
2694 const size_t default_page_size = (size_t) vm_page_size();
2695 if (success && _large_page_size > default_page_size) {
2696 _page_sizes[0] = _large_page_size;
2697 _page_sizes[1] = default_page_size;
2698 _page_sizes[2] = 0;
2699 }
2700
2701 cleanup_after_large_page_init();
2702 UseLargePages = success;
2703 }
2704
2705 // On win32, one cannot release just a part of reserved memory, it's an
2706 // all or nothing deal. When we split a reservation, we must break the
2707 // reservation into two reservations.
2708 void os::split_reserved_memory(char *base, size_t size, size_t split,
2709 bool realloc) {
2710 if (size > 0) {
2711 release_memory(base, size);
2712 if (realloc) {
2713 reserve_memory(split, base);
2714 }
2715 if (size != split) {
2716 reserve_memory(size - split, base + split);
2717 }
2718 }
2719 }
2720
2721 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
2722 assert((size_t)addr % os::vm_allocation_granularity() == 0,
2723 "reserve alignment");
2724 assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
2725 char* res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
2726 assert(res == NULL || addr == NULL || addr == res,
2727 "Unexpected address from reserve.");
2728 return res;
2729 }
2730
2731 // Reserve memory at an arbitrary address, only if that area is
2732 // available (and not reserved for something else).
2733 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2734 // Windows os::reserve_memory() fails of the requested address range is
2735 // not avilable.
2736 return reserve_memory(bytes, requested_addr);
2737 }
2738
2739 size_t os::large_page_size() {
2740 return _large_page_size;
2741 }
2742
2743 bool os::can_commit_large_page_memory() {
2744 // Windows only uses large page memory when the entire region is reserved
2745 // and committed in a single VirtualAlloc() call. This may change in the
2746 // future, but with Windows 2003 it's not possible to commit on demand.
2747 return false;
2748 }
2749
2750 bool os::can_execute_large_page_memory() {
2751 return true;
2752 }
2753
2754 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
2755
2756 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
2757
2758 if (UseLargePagesIndividualAllocation) {
2759 if (TracePageSizes && Verbose) {
2760 tty->print_cr("Reserving large pages individually.");
2761 }
2762 char * p_buf;
2763 // first reserve enough address space in advance since we want to be
2764 // able to break a single contiguous virtual address range into multiple
2765 // large page commits but WS2003 does not allow reserving large page space
2766 // so we just use 4K pages for reserve, this gives us a legal contiguous
2767 // address space. then we will deallocate that reservation, and re alloc
2768 // using large pages
2769 const size_t size_of_reserve = bytes + _large_page_size;
2770 if (bytes > size_of_reserve) {
2771 // Overflowed.
2772 warning("Individually allocated large pages failed, "
2773 "use -XX:-UseLargePagesIndividualAllocation to turn off");
2774 return NULL;
2775 }
2776 p_buf = (char *) VirtualAlloc(addr,
2777 size_of_reserve, // size of Reserve
2778 MEM_RESERVE,
2779 PAGE_READWRITE);
2780 // If reservation failed, return NULL
2781 if (p_buf == NULL) return NULL;
2782
2783 release_memory(p_buf, bytes + _large_page_size);
2784 // round up to page boundary. If the size_of_reserve did not
2785 // overflow and the reservation did not fail, this align up
2786 // should not overflow.
2787 p_buf = (char *) align_size_up((size_t)p_buf, _large_page_size);
2788
2789 // now go through and allocate one page at a time until all bytes are
2790 // allocated
2791 size_t bytes_remaining = align_size_up(bytes, _large_page_size);
2792 // An overflow of align_size_up() would have been caught above
2793 // in the calculation of size_of_reserve.
2794 char * next_alloc_addr = p_buf;
2795
2796 #ifdef ASSERT
2797 // Variable for the failure injection
2798 long ran_num = os::random();
2799 size_t fail_after = ran_num % bytes;
2800 #endif
2801
2802 while (bytes_remaining) {
2803 size_t bytes_to_rq = MIN2(bytes_remaining, _large_page_size);
2804 // Note allocate and commit
2805 char * p_new;
2806
2807 #ifdef ASSERT
2808 bool inject_error = LargePagesIndividualAllocationInjectError &&
2809 (bytes_remaining <= fail_after);
2810 #else
2811 const bool inject_error = false;
2812 #endif
2813
2814 if (inject_error) {
2815 p_new = NULL;
2816 } else {
2817 p_new = (char *) VirtualAlloc(next_alloc_addr,
2818 bytes_to_rq,
2819 MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES,
2820 prot);
2821 }
2822
2823 if (p_new == NULL) {
2824 // Free any allocated pages
2825 if (next_alloc_addr > p_buf) {
2826 // Some memory was committed so release it.
2827 size_t bytes_to_release = bytes - bytes_remaining;
2828 release_memory(p_buf, bytes_to_release);
2829 }
2830 #ifdef ASSERT
2831 if (UseLargePagesIndividualAllocation &&
2832 LargePagesIndividualAllocationInjectError) {
2833 if (TracePageSizes && Verbose) {
2834 tty->print_cr("Reserving large pages individually failed.");
2835 }
2836 }
2837 #endif
2838 return NULL;
2839 }
2840 bytes_remaining -= bytes_to_rq;
2841 next_alloc_addr += bytes_to_rq;
2842 }
2843
2844 return p_buf;
2845
2846 } else {
2847 // normal policy just allocate it all at once
2848 DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
2849 char * res = (char *)VirtualAlloc(NULL, bytes, flag, prot);
2850 return res;
2851 }
2852 }
2853
2854 bool os::release_memory_special(char* base, size_t bytes) {
2855 return release_memory(base, bytes);
2856 }
2857
2858 void os::print_statistics() {
2859 }
2860
2861 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
2862 if (bytes == 0) {
2863 // Don't bother the OS with noops.
2864 return true;
2865 }
2866 assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
2867 assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
2868 // Don't attempt to print anything if the OS call fails. We're
2869 // probably low on resources, so the print itself may cause crashes.
2870 bool result = VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) != 0;
2871 if (result != NULL && exec) {
2872 DWORD oldprot;
2873 // Windows doc says to use VirtualProtect to get execute permissions
2874 return VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot) != 0;
2875 } else {
2876 return result;
2877 }
2878 }
2879
2880 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
2881 bool exec) {
2882 return commit_memory(addr, size, exec);
2883 }
2884
2885 bool os::uncommit_memory(char* addr, size_t bytes) {
2886 if (bytes == 0) {
2887 // Don't bother the OS with noops.
2888 return true;
2889 }
2890 assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
2891 assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
2892 return VirtualFree(addr, bytes, MEM_DECOMMIT) != 0;
2893 }
2894
2895 bool os::release_memory(char* addr, size_t bytes) {
2896 return VirtualFree(addr, 0, MEM_RELEASE) != 0;
2897 }
2898
2899 bool os::create_stack_guard_pages(char* addr, size_t size) {
2900 return os::commit_memory(addr, size);
2901 }
2902
2903 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2904 return os::uncommit_memory(addr, size);
2905 }
2906
2907 // Set protections specified
2908 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
2909 bool is_committed) {
2910 unsigned int p = 0;
2911 switch (prot) {
2912 case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
2913 case MEM_PROT_READ: p = PAGE_READONLY; break;
2914 case MEM_PROT_RW: p = PAGE_READWRITE; break;
2915 case MEM_PROT_RWX: p = PAGE_EXECUTE_READWRITE; break;
2916 default:
2917 ShouldNotReachHere();
2918 }
2919
2920 DWORD old_status;
2921
2922 // Strange enough, but on Win32 one can change protection only for committed
2923 // memory, not a big deal anyway, as bytes less or equal than 64K
2924 if (!is_committed && !commit_memory(addr, bytes, prot == MEM_PROT_RWX)) {
2925 fatal("cannot commit protection page");
2926 }
2927 // One cannot use os::guard_memory() here, as on Win32 guard page
2928 // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
2929 //
2930 // Pages in the region become guard pages. Any attempt to access a guard page
2931 // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
2932 // the guard page status. Guard pages thus act as a one-time access alarm.
2933 return VirtualProtect(addr, bytes, p, &old_status) != 0;
2934 }
2935
2936 bool os::guard_memory(char* addr, size_t bytes) {
2937 DWORD old_status;
2938 return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
2939 }
2940
2941 bool os::unguard_memory(char* addr, size_t bytes) {
2942 DWORD old_status;
2943 return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
2944 }
2945
2946 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
2947 void os::free_memory(char *addr, size_t bytes) { }
2948 void os::numa_make_global(char *addr, size_t bytes) { }
2949 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) { }
2950 bool os::numa_topology_changed() { return false; }
2951 size_t os::numa_get_groups_num() { return 1; }
2952 int os::numa_get_group_id() { return 0; }
2953 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2954 if (size > 0) {
2955 ids[0] = 0;
2956 return 1;
2957 }
2958 return 0;
2959 }
2960
2961 bool os::get_page_info(char *start, page_info* info) {
2962 return false;
2963 }
2964
2965 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2966 return end;
2967 }
2968
2969 char* os::non_memory_address_word() {
2970 // Must never look like an address returned by reserve_memory,
2971 // even in its subfields (as defined by the CPU immediate fields,
2972 // if the CPU splits constants across multiple instructions).
2973 return (char*)-1;
2974 }
2975
2976 #define MAX_ERROR_COUNT 100
2977 #define SYS_THREAD_ERROR 0xffffffffUL
2978
2979 void os::pd_start_thread(Thread* thread) {
2980 DWORD ret = ResumeThread(thread->osthread()->thread_handle());
2981 // Returns previous suspend state:
2982 // 0: Thread was not suspended
2983 // 1: Thread is running now
2984 // >1: Thread is still suspended.
2985 assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
2986 }
2987
2988 class HighResolutionInterval {
2989 // The default timer resolution seems to be 10 milliseconds.
2990 // (Where is this written down?)
2991 // If someone wants to sleep for only a fraction of the default,
2992 // then we set the timer resolution down to 1 millisecond for
2993 // the duration of their interval.
2994 // We carefully set the resolution back, since otherwise we
2995 // seem to incur an overhead (3%?) that we don't need.
2996 // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
2997 // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
2998 // Alternatively, we could compute the relative error (503/500 = .6%) and only use
2999 // timeBeginPeriod() if the relative error exceeded some threshold.
3000 // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3001 // to decreased efficiency related to increased timer "tick" rates. We want to minimize
3002 // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3003 // resolution timers running.
3004 private:
3005 jlong resolution;
3006 public:
3007 HighResolutionInterval(jlong ms) {
3008 resolution = ms % 10L;
3009 if (resolution != 0) {
3010 MMRESULT result = timeBeginPeriod(1L);
3011 }
3012 }
3013 ~HighResolutionInterval() {
3014 if (resolution != 0) {
3015 MMRESULT result = timeEndPeriod(1L);
3016 }
3017 resolution = 0L;
3018 }
3019 };
3020
3021 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3022 jlong limit = (jlong) MAXDWORD;
3023
3024 while(ms > limit) {
3025 int res;
3026 if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3027 return res;
3028 ms -= limit;
3029 }
3030
3031 assert(thread == Thread::current(), "thread consistency check");
3032 OSThread* osthread = thread->osthread();
3033 OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3034 int result;
3035 if (interruptable) {
3036 assert(thread->is_Java_thread(), "must be java thread");
3037 JavaThread *jt = (JavaThread *) thread;
3038 ThreadBlockInVM tbivm(jt);
3039
3040 jt->set_suspend_equivalent();
3041 // cleared by handle_special_suspend_equivalent_condition() or
3042 // java_suspend_self() via check_and_wait_while_suspended()
3043
3044 HANDLE events[1];
3045 events[0] = osthread->interrupt_event();
3046 HighResolutionInterval *phri=NULL;
3047 if(!ForceTimeHighResolution)
3048 phri = new HighResolutionInterval( ms );
3049 if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3050 result = OS_TIMEOUT;
3051 } else {
3052 ResetEvent(osthread->interrupt_event());
3053 osthread->set_interrupted(false);
3054 result = OS_INTRPT;
3055 }
3056 delete phri; //if it is NULL, harmless
3057
3058 // were we externally suspended while we were waiting?
3059 jt->check_and_wait_while_suspended();
3060 } else {
3061 assert(!thread->is_Java_thread(), "must not be java thread");
3062 Sleep((long) ms);
3063 result = OS_TIMEOUT;
3064 }
3065 return result;
3066 }
3067
3068 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3069 void os::infinite_sleep() {
3070 while (true) { // sleep forever ...
3071 Sleep(100000); // ... 100 seconds at a time
3072 }
3073 }
3074
3075 typedef BOOL (WINAPI * STTSignature)(void) ;
3076
3077 os::YieldResult os::NakedYield() {
3078 // Use either SwitchToThread() or Sleep(0)
3079 // Consider passing back the return value from SwitchToThread().
3080 if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3081 return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3082 } else {
3083 Sleep(0);
3084 }
3085 return os::YIELD_UNKNOWN ;
3086 }
3087
3088 void os::yield() { os::NakedYield(); }
3089
3090 void os::yield_all(int attempts) {
3091 // Yields to all threads, including threads with lower priorities
3092 Sleep(1);
3093 }
3094
3095 // Win32 only gives you access to seven real priorities at a time,
3096 // so we compress Java's ten down to seven. It would be better
3097 // if we dynamically adjusted relative priorities.
3098
3099 int os::java_to_os_priority[MaxPriority + 1] = {
3100 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3101 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3102 THREAD_PRIORITY_LOWEST, // 2
3103 THREAD_PRIORITY_BELOW_NORMAL, // 3
3104 THREAD_PRIORITY_BELOW_NORMAL, // 4
3105 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3106 THREAD_PRIORITY_NORMAL, // 6
3107 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3108 THREAD_PRIORITY_ABOVE_NORMAL, // 8
3109 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3110 THREAD_PRIORITY_HIGHEST // 10 MaxPriority
3111 };
3112
3113 int prio_policy1[MaxPriority + 1] = {
3114 THREAD_PRIORITY_IDLE, // 0 Entry should never be used
3115 THREAD_PRIORITY_LOWEST, // 1 MinPriority
3116 THREAD_PRIORITY_LOWEST, // 2
3117 THREAD_PRIORITY_BELOW_NORMAL, // 3
3118 THREAD_PRIORITY_BELOW_NORMAL, // 4
3119 THREAD_PRIORITY_NORMAL, // 5 NormPriority
3120 THREAD_PRIORITY_ABOVE_NORMAL, // 6
3121 THREAD_PRIORITY_ABOVE_NORMAL, // 7
3122 THREAD_PRIORITY_HIGHEST, // 8
3123 THREAD_PRIORITY_HIGHEST, // 9 NearMaxPriority
3124 THREAD_PRIORITY_TIME_CRITICAL // 10 MaxPriority
3125 };
3126
3127 static int prio_init() {
3128 // If ThreadPriorityPolicy is 1, switch tables
3129 if (ThreadPriorityPolicy == 1) {
3130 int i;
3131 for (i = 0; i < MaxPriority + 1; i++) {
3132 os::java_to_os_priority[i] = prio_policy1[i];
3133 }
3134 }
3135 return 0;
3136 }
3137
3138 OSReturn os::set_native_priority(Thread* thread, int priority) {
3139 if (!UseThreadPriorities) return OS_OK;
3140 bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3141 return ret ? OS_OK : OS_ERR;
3142 }
3143
3144 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3145 if ( !UseThreadPriorities ) {
3146 *priority_ptr = java_to_os_priority[NormPriority];
3147 return OS_OK;
3148 }
3149 int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3150 if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3151 assert(false, "GetThreadPriority failed");
3152 return OS_ERR;
3153 }
3154 *priority_ptr = os_prio;
3155 return OS_OK;
3156 }
3157
3158
3159 // Hint to the underlying OS that a task switch would not be good.
3160 // Void return because it's a hint and can fail.
3161 void os::hint_no_preempt() {}
3162
3163 void os::interrupt(Thread* thread) {
3164 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3165 "possibility of dangling Thread pointer");
3166
3167 OSThread* osthread = thread->osthread();
3168 osthread->set_interrupted(true);
3169 // More than one thread can get here with the same value of osthread,
3170 // resulting in multiple notifications. We do, however, want the store
3171 // to interrupted() to be visible to other threads before we post
3172 // the interrupt event.
3173 OrderAccess::release();
3174 SetEvent(osthread->interrupt_event());
3175 // For JSR166: unpark after setting status
3176 if (thread->is_Java_thread())
3177 ((JavaThread*)thread)->parker()->unpark();
3178
3179 ParkEvent * ev = thread->_ParkEvent ;
3180 if (ev != NULL) ev->unpark() ;
3181
3182 }
3183
3184
3185 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3186 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3187 "possibility of dangling Thread pointer");
3188
3189 OSThread* osthread = thread->osthread();
3190 bool interrupted = osthread->interrupted();
3191 // There is no synchronization between the setting of the interrupt
3192 // and it being cleared here. It is critical - see 6535709 - that
3193 // we only clear the interrupt state, and reset the interrupt event,
3194 // if we are going to report that we were indeed interrupted - else
3195 // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3196 // depending on the timing
3197 if (interrupted && clear_interrupted) {
3198 osthread->set_interrupted(false);
3199 ResetEvent(osthread->interrupt_event());
3200 } // Otherwise leave the interrupted state alone
3201
3202 return interrupted;
3203 }
3204
3205 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3206 ExtendedPC os::get_thread_pc(Thread* thread) {
3207 CONTEXT context;
3208 context.ContextFlags = CONTEXT_CONTROL;
3209 HANDLE handle = thread->osthread()->thread_handle();
3210 #ifdef _M_IA64
3211 assert(0, "Fix get_thread_pc");
3212 return ExtendedPC(NULL);
3213 #else
3214 if (GetThreadContext(handle, &context)) {
3215 #ifdef _M_AMD64
3216 return ExtendedPC((address) context.Rip);
3217 #else
3218 return ExtendedPC((address) context.Eip);
3219 #endif
3220 } else {
3221 return ExtendedPC(NULL);
3222 }
3223 #endif
3224 }
3225
3226 // GetCurrentThreadId() returns DWORD
3227 intx os::current_thread_id() { return GetCurrentThreadId(); }
3228
3229 static int _initial_pid = 0;
3230
3231 int os::current_process_id()
3232 {
3233 return (_initial_pid ? _initial_pid : _getpid());
3234 }
3235
3236 int os::win32::_vm_page_size = 0;
3237 int os::win32::_vm_allocation_granularity = 0;
3238 int os::win32::_processor_type = 0;
3239 // Processor level is not available on non-NT systems, use vm_version instead
3240 int os::win32::_processor_level = 0;
3241 julong os::win32::_physical_memory = 0;
3242 size_t os::win32::_default_stack_size = 0;
3243
3244 intx os::win32::_os_thread_limit = 0;
3245 volatile intx os::win32::_os_thread_count = 0;
3246
3247 bool os::win32::_is_nt = false;
3248 bool os::win32::_is_windows_2003 = false;
3249 bool os::win32::_is_windows_server = false;
3250
3251 void os::win32::initialize_system_info() {
3252 SYSTEM_INFO si;
3253 GetSystemInfo(&si);
3254 _vm_page_size = si.dwPageSize;
3255 _vm_allocation_granularity = si.dwAllocationGranularity;
3256 _processor_type = si.dwProcessorType;
3257 _processor_level = si.wProcessorLevel;
3258 set_processor_count(si.dwNumberOfProcessors);
3259
3260 MEMORYSTATUSEX ms;
3261 ms.dwLength = sizeof(ms);
3262
3263 // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3264 // dwMemoryLoad (% of memory in use)
3265 GlobalMemoryStatusEx(&ms);
3266 _physical_memory = ms.ullTotalPhys;
3267
3268 OSVERSIONINFOEX oi;
3269 oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3270 GetVersionEx((OSVERSIONINFO*)&oi);
3271 switch(oi.dwPlatformId) {
3272 case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3273 case VER_PLATFORM_WIN32_NT:
3274 _is_nt = true;
3275 {
3276 int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3277 if (os_vers == 5002) {
3278 _is_windows_2003 = true;
3279 }
3280 if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3281 oi.wProductType == VER_NT_SERVER) {
3282 _is_windows_server = true;
3283 }
3284 }
3285 break;
3286 default: fatal("Unknown platform");
3287 }
3288
3289 _default_stack_size = os::current_stack_size();
3290 assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3291 assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3292 "stack size not a multiple of page size");
3293
3294 initialize_performance_counter();
3295
3296 // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3297 // known to deadlock the system, if the VM issues to thread operations with
3298 // a too high frequency, e.g., such as changing the priorities.
3299 // The 6000 seems to work well - no deadlocks has been notices on the test
3300 // programs that we have seen experience this problem.
3301 if (!os::win32::is_nt()) {
3302 StarvationMonitorInterval = 6000;
3303 }
3304 }
3305
3306
3307 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3308 char path[MAX_PATH];
3309 DWORD size;
3310 DWORD pathLen = (DWORD)sizeof(path);
3311 HINSTANCE result = NULL;
3312
3313 // only allow library name without path component
3314 assert(strchr(name, '\\') == NULL, "path not allowed");
3315 assert(strchr(name, ':') == NULL, "path not allowed");
3316 if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3317 jio_snprintf(ebuf, ebuflen,
3318 "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3319 return NULL;
3320 }
3321
3322 // search system directory
3323 if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3324 strcat(path, "\\");
3325 strcat(path, name);
3326 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3327 return result;
3328 }
3329 }
3330
3331 // try Windows directory
3332 if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3333 strcat(path, "\\");
3334 strcat(path, name);
3335 if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3336 return result;
3337 }
3338 }
3339
3340 jio_snprintf(ebuf, ebuflen,
3341 "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3342 return NULL;
3343 }
3344
3345 void os::win32::setmode_streams() {
3346 _setmode(_fileno(stdin), _O_BINARY);
3347 _setmode(_fileno(stdout), _O_BINARY);
3348 _setmode(_fileno(stderr), _O_BINARY);
3349 }
3350
3351
3352 bool os::is_debugger_attached() {
3353 return IsDebuggerPresent() ? true : false;
3354 }
3355
3356
3357 void os::wait_for_keypress_at_exit(void) {
3358 if (PauseAtExit) {
3359 fprintf(stderr, "Press any key to continue...\n");
3360 fgetc(stdin);
3361 }
3362 }
3363
3364
3365 int os::message_box(const char* title, const char* message) {
3366 int result = MessageBox(NULL, message, title,
3367 MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3368 return result == IDYES;
3369 }
3370
3371 int os::allocate_thread_local_storage() {
3372 return TlsAlloc();
3373 }
3374
3375
3376 void os::free_thread_local_storage(int index) {
3377 TlsFree(index);
3378 }
3379
3380
3381 void os::thread_local_storage_at_put(int index, void* value) {
3382 TlsSetValue(index, value);
3383 assert(thread_local_storage_at(index) == value, "Just checking");
3384 }
3385
3386
3387 void* os::thread_local_storage_at(int index) {
3388 return TlsGetValue(index);
3389 }
3390
3391
3392 #ifndef PRODUCT
3393 #ifndef _WIN64
3394 // Helpers to check whether NX protection is enabled
3395 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3396 if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3397 pex->ExceptionRecord->NumberParameters > 0 &&
3398 pex->ExceptionRecord->ExceptionInformation[0] ==
3399 EXCEPTION_INFO_EXEC_VIOLATION) {
3400 return EXCEPTION_EXECUTE_HANDLER;
3401 }
3402 return EXCEPTION_CONTINUE_SEARCH;
3403 }
3404
3405 void nx_check_protection() {
3406 // If NX is enabled we'll get an exception calling into code on the stack
3407 char code[] = { (char)0xC3 }; // ret
3408 void *code_ptr = (void *)code;
3409 __try {
3410 __asm call code_ptr
3411 } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
3412 tty->print_raw_cr("NX protection detected.");
3413 }
3414 }
3415 #endif // _WIN64
3416 #endif // PRODUCT
3417
3418 // this is called _before_ the global arguments have been parsed
3419 void os::init(void) {
3420 _initial_pid = _getpid();
3421
3422 init_random(1234567);
3423
3424 win32::initialize_system_info();
3425 win32::setmode_streams();
3426 init_page_sizes((size_t) win32::vm_page_size());
3427
3428 // For better scalability on MP systems (must be called after initialize_system_info)
3429 #ifndef PRODUCT
3430 if (is_MP()) {
3431 NoYieldsInMicrolock = true;
3432 }
3433 #endif
3434 // This may be overridden later when argument processing is done.
3435 FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
3436 os::win32::is_windows_2003());
3437
3438 // Initialize main_process and main_thread
3439 main_process = GetCurrentProcess(); // Remember main_process is a pseudo handle
3440 if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
3441 &main_thread, THREAD_ALL_ACCESS, false, 0)) {
3442 fatal("DuplicateHandle failed\n");
3443 }
3444 main_thread_id = (int) GetCurrentThreadId();
3445 }
3446
3447 // To install functions for atexit processing
3448 extern "C" {
3449 static void perfMemory_exit_helper() {
3450 perfMemory_exit();
3451 }
3452 }
3453
3454 // this is called _after_ the global arguments have been parsed
3455 jint os::init_2(void) {
3456 // Allocate a single page and mark it as readable for safepoint polling
3457 address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
3458 guarantee( polling_page != NULL, "Reserve Failed for polling page");
3459
3460 address return_page = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
3461 guarantee( return_page != NULL, "Commit Failed for polling page");
3462
3463 os::set_polling_page( polling_page );
3464
3465 #ifndef PRODUCT
3466 if( Verbose && PrintMiscellaneous )
3467 tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
3468 #endif
3469
3470 if (!UseMembar) {
3471 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
3472 guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
3473
3474 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
3475 guarantee( return_page != NULL, "Commit Failed for memory serialize page");
3476
3477 os::set_memory_serialize_page( mem_serialize_page );
3478
3479 #ifndef PRODUCT
3480 if(Verbose && PrintMiscellaneous)
3481 tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3482 #endif
3483 }
3484
3485 os::large_page_init();
3486
3487 // Setup Windows Exceptions
3488
3489 // On Itanium systems, Structured Exception Handling does not
3490 // work since stack frames must be walkable by the OS. Since
3491 // much of our code is dynamically generated, and we do not have
3492 // proper unwind .xdata sections, the system simply exits
3493 // rather than delivering the exception. To work around
3494 // this we use VectorExceptions instead.
3495 #ifdef _WIN64
3496 if (UseVectoredExceptions) {
3497 topLevelVectoredExceptionHandler = AddVectoredExceptionHandler( 1, topLevelExceptionFilter);
3498 }
3499 #endif
3500
3501 // for debugging float code generation bugs
3502 if (ForceFloatExceptions) {
3503 #ifndef _WIN64
3504 static long fp_control_word = 0;
3505 __asm { fstcw fp_control_word }
3506 // see Intel PPro Manual, Vol. 2, p 7-16
3507 const long precision = 0x20;
3508 const long underflow = 0x10;
3509 const long overflow = 0x08;
3510 const long zero_div = 0x04;
3511 const long denorm = 0x02;
3512 const long invalid = 0x01;
3513 fp_control_word |= invalid;
3514 __asm { fldcw fp_control_word }
3515 #endif
3516 }
3517
3518 // If stack_commit_size is 0, windows will reserve the default size,
3519 // but only commit a small portion of it.
3520 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
3521 size_t default_reserve_size = os::win32::default_stack_size();
3522 size_t actual_reserve_size = stack_commit_size;
3523 if (stack_commit_size < default_reserve_size) {
3524 // If stack_commit_size == 0, we want this too
3525 actual_reserve_size = default_reserve_size;
3526 }
3527
3528 // Check minimum allowable stack size for thread creation and to initialize
3529 // the java system classes, including StackOverflowError - depends on page
3530 // size. Add a page for compiler2 recursion in main thread.
3531 // Add in 2*BytesPerWord times page size to account for VM stack during
3532 // class initialization depending on 32 or 64 bit VM.
3533 size_t min_stack_allowed =
3534 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
3535 2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
3536 if (actual_reserve_size < min_stack_allowed) {
3537 tty->print_cr("\nThe stack size specified is too small, "
3538 "Specify at least %dk",
3539 min_stack_allowed / K);
3540 return JNI_ERR;
3541 }
3542
3543 JavaThread::set_stack_size_at_create(stack_commit_size);
3544
3545 // Calculate theoretical max. size of Threads to guard gainst artifical
3546 // out-of-memory situations, where all available address-space has been
3547 // reserved by thread stacks.
3548 assert(actual_reserve_size != 0, "Must have a stack");
3549
3550 // Calculate the thread limit when we should start doing Virtual Memory
3551 // banging. Currently when the threads will have used all but 200Mb of space.
3552 //
3553 // TODO: consider performing a similar calculation for commit size instead
3554 // as reserve size, since on a 64-bit platform we'll run into that more
3555 // often than running out of virtual memory space. We can use the
3556 // lower value of the two calculations as the os_thread_limit.
3557 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
3558 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
3559
3560 // at exit methods are called in the reverse order of their registration.
3561 // there is no limit to the number of functions registered. atexit does
3562 // not set errno.
3563
3564 if (PerfAllowAtExitRegistration) {
3565 // only register atexit functions if PerfAllowAtExitRegistration is set.
3566 // atexit functions can be delayed until process exit time, which
3567 // can be problematic for embedded VM situations. Embedded VMs should
3568 // call DestroyJavaVM() to assure that VM resources are released.
3569
3570 // note: perfMemory_exit_helper atexit function may be removed in
3571 // the future if the appropriate cleanup code can be added to the
3572 // VM_Exit VMOperation's doit method.
3573 if (atexit(perfMemory_exit_helper) != 0) {
3574 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3575 }
3576 }
3577
3578 #ifndef _WIN64
3579 // Print something if NX is enabled (win32 on AMD64)
3580 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
3581 #endif
3582
3583 // initialize thread priority policy
3584 prio_init();
3585
3586 if (UseNUMA && !ForceNUMA) {
3587 UseNUMA = false; // Currently unsupported.
3588 }
3589
3590 return JNI_OK;
3591 }
3592
3593 void os::init_3(void) {
3594 return;
3595 }
3596
3597 // Mark the polling page as unreadable
3598 void os::make_polling_page_unreadable(void) {
3599 DWORD old_status;
3600 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
3601 fatal("Could not disable polling page");
3602 };
3603
3604 // Mark the polling page as readable
3605 void os::make_polling_page_readable(void) {
3606 DWORD old_status;
3607 if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
3608 fatal("Could not enable polling page");
3609 };
3610
3611
3612 int os::stat(const char *path, struct stat *sbuf) {
3613 char pathbuf[MAX_PATH];
3614 if (strlen(path) > MAX_PATH - 1) {
3615 errno = ENAMETOOLONG;
3616 return -1;
3617 }
3618 os::native_path(strcpy(pathbuf, path));
3619 int ret = ::stat(pathbuf, sbuf);
3620 if (sbuf != NULL && UseUTCFileTimestamp) {
3621 // Fix for 6539723. st_mtime returned from stat() is dependent on
3622 // the system timezone and so can return different values for the
3623 // same file if/when daylight savings time changes. This adjustment
3624 // makes sure the same timestamp is returned regardless of the TZ.
3625 //
3626 // See:
3627 // http://msdn.microsoft.com/library/
3628 // default.asp?url=/library/en-us/sysinfo/base/
3629 // time_zone_information_str.asp
3630 // and
3631 // http://msdn.microsoft.com/library/default.asp?url=
3632 // /library/en-us/sysinfo/base/settimezoneinformation.asp
3633 //
3634 // NOTE: there is a insidious bug here: If the timezone is changed
3635 // after the call to stat() but before 'GetTimeZoneInformation()', then
3636 // the adjustment we do here will be wrong and we'll return the wrong
3637 // value (which will likely end up creating an invalid class data
3638 // archive). Absent a better API for this, or some time zone locking
3639 // mechanism, we'll have to live with this risk.
3640 TIME_ZONE_INFORMATION tz;
3641 DWORD tzid = GetTimeZoneInformation(&tz);
3642 int daylightBias =
3643 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias;
3644 sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
3645 }
3646 return ret;
3647 }
3648
3649
3650 #define FT2INT64(ft) \
3651 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
3652
3653
3654 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
3655 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
3656 // of a thread.
3657 //
3658 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
3659 // the fast estimate available on the platform.
3660
3661 // current_thread_cpu_time() is not optimized for Windows yet
3662 jlong os::current_thread_cpu_time() {
3663 // return user + sys since the cost is the same
3664 return os::thread_cpu_time(Thread::current(), true /* user+sys */);
3665 }
3666
3667 jlong os::thread_cpu_time(Thread* thread) {
3668 // consistent with what current_thread_cpu_time() returns.
3669 return os::thread_cpu_time(thread, true /* user+sys */);
3670 }
3671
3672 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
3673 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
3674 }
3675
3676 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
3677 // This code is copy from clasic VM -> hpi::sysThreadCPUTime
3678 // If this function changes, os::is_thread_cpu_time_supported() should too
3679 if (os::win32::is_nt()) {
3680 FILETIME CreationTime;
3681 FILETIME ExitTime;
3682 FILETIME KernelTime;
3683 FILETIME UserTime;
3684
3685 if ( GetThreadTimes(thread->osthread()->thread_handle(),
3686 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3687 return -1;
3688 else
3689 if (user_sys_cpu_time) {
3690 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
3691 } else {
3692 return FT2INT64(UserTime) * 100;
3693 }
3694 } else {
3695 return (jlong) timeGetTime() * 1000000;
3696 }
3697 }
3698
3699 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3700 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3701 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3702 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3703 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3704 }
3705
3706 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
3707 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
3708 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
3709 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
3710 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
3711 }
3712
3713 bool os::is_thread_cpu_time_supported() {
3714 // see os::thread_cpu_time
3715 if (os::win32::is_nt()) {
3716 FILETIME CreationTime;
3717 FILETIME ExitTime;
3718 FILETIME KernelTime;
3719 FILETIME UserTime;
3720
3721 if ( GetThreadTimes(GetCurrentThread(),
3722 &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
3723 return false;
3724 else
3725 return true;
3726 } else {
3727 return false;
3728 }
3729 }
3730
3731 // Windows does't provide a loadavg primitive so this is stubbed out for now.
3732 // It does have primitives (PDH API) to get CPU usage and run queue length.
3733 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
3734 // If we wanted to implement loadavg on Windows, we have a few options:
3735 //
3736 // a) Query CPU usage and run queue length and "fake" an answer by
3737 // returning the CPU usage if it's under 100%, and the run queue
3738 // length otherwise. It turns out that querying is pretty slow
3739 // on Windows, on the order of 200 microseconds on a fast machine.
3740 // Note that on the Windows the CPU usage value is the % usage
3741 // since the last time the API was called (and the first call
3742 // returns 100%), so we'd have to deal with that as well.
3743 //
3744 // b) Sample the "fake" answer using a sampling thread and store
3745 // the answer in a global variable. The call to loadavg would
3746 // just return the value of the global, avoiding the slow query.
3747 //
3748 // c) Sample a better answer using exponential decay to smooth the
3749 // value. This is basically the algorithm used by UNIX kernels.
3750 //
3751 // Note that sampling thread starvation could affect both (b) and (c).
3752 int os::loadavg(double loadavg[], int nelem) {
3753 return -1;
3754 }
3755
3756
3757 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
3758 bool os::dont_yield() {
3759 return DontYieldALot;
3760 }
3761
3762 // This method is a slightly reworked copy of JDK's sysOpen
3763 // from src/windows/hpi/src/sys_api_md.c
3764
3765 int os::open(const char *path, int oflag, int mode) {
3766 char pathbuf[MAX_PATH];
3767
3768 if (strlen(path) > MAX_PATH - 1) {
3769 errno = ENAMETOOLONG;
3770 return -1;
3771 }
3772 os::native_path(strcpy(pathbuf, path));
3773 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
3774 }
3775
3776 // Is a (classpath) directory empty?
3777 bool os::dir_is_empty(const char* path) {
3778 WIN32_FIND_DATA fd;
3779 HANDLE f = FindFirstFile(path, &fd);
3780 if (f == INVALID_HANDLE_VALUE) {
3781 return true;
3782 }
3783 FindClose(f);
3784 return false;
3785 }
3786
3787 // create binary file, rewriting existing file if required
3788 int os::create_binary_file(const char* path, bool rewrite_existing) {
3789 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
3790 if (!rewrite_existing) {
3791 oflags |= _O_EXCL;
3792 }
3793 return ::open(path, oflags, _S_IREAD | _S_IWRITE);
3794 }
3795
3796 // return current position of file pointer
3797 jlong os::current_file_offset(int fd) {
3798 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
3799 }
3800
3801 // move file pointer to the specified offset
3802 jlong os::seek_to_file_offset(int fd, jlong offset) {
3803 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
3804 }
3805
3806
3807 jlong os::lseek(int fd, jlong offset, int whence) {
3808 return (jlong) ::_lseeki64(fd, offset, whence);
3809 }
3810
3811 // This method is a slightly reworked copy of JDK's sysNativePath
3812 // from src/windows/hpi/src/path_md.c
3813
3814 /* Convert a pathname to native format. On win32, this involves forcing all
3815 separators to be '\\' rather than '/' (both are legal inputs, but Win95
3816 sometimes rejects '/') and removing redundant separators. The input path is
3817 assumed to have been converted into the character encoding used by the local
3818 system. Because this might be a double-byte encoding, care is taken to
3819 treat double-byte lead characters correctly.
3820
3821 This procedure modifies the given path in place, as the result is never
3822 longer than the original. There is no error return; this operation always
3823 succeeds. */
3824 char * os::native_path(char *path) {
3825 char *src = path, *dst = path, *end = path;
3826 char *colon = NULL; /* If a drive specifier is found, this will
3827 point to the colon following the drive
3828 letter */
3829
3830 /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
3831 assert(((!::IsDBCSLeadByte('/'))
3832 && (!::IsDBCSLeadByte('\\'))
3833 && (!::IsDBCSLeadByte(':'))),
3834 "Illegal lead byte");
3835
3836 /* Check for leading separators */
3837 #define isfilesep(c) ((c) == '/' || (c) == '\\')
3838 while (isfilesep(*src)) {
3839 src++;
3840 }
3841
3842 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
3843 /* Remove leading separators if followed by drive specifier. This
3844 hack is necessary to support file URLs containing drive
3845 specifiers (e.g., "file://c:/path"). As a side effect,
3846 "/c:/path" can be used as an alternative to "c:/path". */
3847 *dst++ = *src++;
3848 colon = dst;
3849 *dst++ = ':';
3850 src++;
3851 } else {
3852 src = path;
3853 if (isfilesep(src[0]) && isfilesep(src[1])) {
3854 /* UNC pathname: Retain first separator; leave src pointed at
3855 second separator so that further separators will be collapsed
3856 into the second separator. The result will be a pathname
3857 beginning with "\\\\" followed (most likely) by a host name. */
3858 src = dst = path + 1;
3859 path[0] = '\\'; /* Force first separator to '\\' */
3860 }
3861 }
3862
3863 end = dst;
3864
3865 /* Remove redundant separators from remainder of path, forcing all
3866 separators to be '\\' rather than '/'. Also, single byte space
3867 characters are removed from the end of the path because those
3868 are not legal ending characters on this operating system.
3869 */
3870 while (*src != '\0') {
3871 if (isfilesep(*src)) {
3872 *dst++ = '\\'; src++;
3873 while (isfilesep(*src)) src++;
3874 if (*src == '\0') {
3875 /* Check for trailing separator */
3876 end = dst;
3877 if (colon == dst - 2) break; /* "z:\\" */
3878 if (dst == path + 1) break; /* "\\" */
3879 if (dst == path + 2 && isfilesep(path[0])) {
3880 /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
3881 beginning of a UNC pathname. Even though it is not, by
3882 itself, a valid UNC pathname, we leave it as is in order
3883 to be consistent with the path canonicalizer as well
3884 as the win32 APIs, which treat this case as an invalid
3885 UNC pathname rather than as an alias for the root
3886 directory of the current drive. */
3887 break;
3888 }
3889 end = --dst; /* Path does not denote a root directory, so
3890 remove trailing separator */
3891 break;
3892 }
3893 end = dst;
3894 } else {
3895 if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
3896 *dst++ = *src++;
3897 if (*src) *dst++ = *src++;
3898 end = dst;
3899 } else { /* Copy a single-byte character */
3900 char c = *src++;
3901 *dst++ = c;
3902 /* Space is not a legal ending character */
3903 if (c != ' ') end = dst;
3904 }
3905 }
3906 }
3907
3908 *end = '\0';
3909
3910 /* For "z:", add "." to work around a bug in the C runtime library */
3911 if (colon == dst - 1) {
3912 path[2] = '.';
3913 path[3] = '\0';
3914 }
3915
3916 #ifdef DEBUG
3917 jio_fprintf(stderr, "sysNativePath: %s\n", path);
3918 #endif DEBUG
3919 return path;
3920 }
3921
3922 // This code is a copy of JDK's sysSetLength
3923 // from src/windows/hpi/src/sys_api_md.c
3924
3925 int os::ftruncate(int fd, jlong length) {
3926 HANDLE h = (HANDLE)::_get_osfhandle(fd);
3927 long high = (long)(length >> 32);
3928 DWORD ret;
3929
3930 if (h == (HANDLE)(-1)) {
3931 return -1;
3932 }
3933
3934 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
3935 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
3936 return -1;
3937 }
3938
3939 if (::SetEndOfFile(h) == FALSE) {
3940 return -1;
3941 }
3942
3943 return 0;
3944 }
3945
3946
3947 // This code is a copy of JDK's sysSync
3948 // from src/windows/hpi/src/sys_api_md.c
3949 // except for the legacy workaround for a bug in Win 98
3950
3951 int os::fsync(int fd) {
3952 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
3953
3954 if ( (!::FlushFileBuffers(handle)) &&
3955 (GetLastError() != ERROR_ACCESS_DENIED) ) {
3956 /* from winerror.h */
3957 return -1;
3958 }
3959 return 0;
3960 }
3961
3962 static int nonSeekAvailable(int, long *);
3963 static int stdinAvailable(int, long *);
3964
3965 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR)
3966 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO)
3967
3968 // This code is a copy of JDK's sysAvailable
3969 // from src/windows/hpi/src/sys_api_md.c
3970
3971 int os::available(int fd, jlong *bytes) {
3972 jlong cur, end;
3973 struct _stati64 stbuf64;
3974
3975 if (::_fstati64(fd, &stbuf64) >= 0) {
3976 int mode = stbuf64.st_mode;
3977 if (S_ISCHR(mode) || S_ISFIFO(mode)) {
3978 int ret;
3979 long lpbytes;
3980 if (fd == 0) {
3981 ret = stdinAvailable(fd, &lpbytes);
3982 } else {
3983 ret = nonSeekAvailable(fd, &lpbytes);
3984 }
3985 (*bytes) = (jlong)(lpbytes);
3986 return ret;
3987 }
3988 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
3989 return FALSE;
3990 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
3991 return FALSE;
3992 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
3993 return FALSE;
3994 }
3995 *bytes = end - cur;
3996 return TRUE;
3997 } else {
3998 return FALSE;
3999 }
4000 }
4001
4002 // This code is a copy of JDK's nonSeekAvailable
4003 // from src/windows/hpi/src/sys_api_md.c
4004
4005 static int nonSeekAvailable(int fd, long *pbytes) {
4006 /* This is used for available on non-seekable devices
4007 * (like both named and anonymous pipes, such as pipes
4008 * connected to an exec'd process).
4009 * Standard Input is a special case.
4010 *
4011 */
4012 HANDLE han;
4013
4014 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4015 return FALSE;
4016 }
4017
4018 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4019 /* PeekNamedPipe fails when at EOF. In that case we
4020 * simply make *pbytes = 0 which is consistent with the
4021 * behavior we get on Solaris when an fd is at EOF.
4022 * The only alternative is to raise an Exception,
4023 * which isn't really warranted.
4024 */
4025 if (::GetLastError() != ERROR_BROKEN_PIPE) {
4026 return FALSE;
4027 }
4028 *pbytes = 0;
4029 }
4030 return TRUE;
4031 }
4032
4033 #define MAX_INPUT_EVENTS 2000
4034
4035 // This code is a copy of JDK's stdinAvailable
4036 // from src/windows/hpi/src/sys_api_md.c
4037
4038 static int stdinAvailable(int fd, long *pbytes) {
4039 HANDLE han;
4040 DWORD numEventsRead = 0; /* Number of events read from buffer */
4041 DWORD numEvents = 0; /* Number of events in buffer */
4042 DWORD i = 0; /* Loop index */
4043 DWORD curLength = 0; /* Position marker */
4044 DWORD actualLength = 0; /* Number of bytes readable */
4045 BOOL error = FALSE; /* Error holder */
4046 INPUT_RECORD *lpBuffer; /* Pointer to records of input events */
4047
4048 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4049 return FALSE;
4050 }
4051
4052 /* Construct an array of input records in the console buffer */
4053 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4054 if (error == 0) {
4055 return nonSeekAvailable(fd, pbytes);
4056 }
4057
4058 /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4059 if (numEvents > MAX_INPUT_EVENTS) {
4060 numEvents = MAX_INPUT_EVENTS;
4061 }
4062
4063 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD));
4064 if (lpBuffer == NULL) {
4065 return FALSE;
4066 }
4067
4068 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4069 if (error == 0) {
4070 os::free(lpBuffer);
4071 return FALSE;
4072 }
4073
4074 /* Examine input records for the number of bytes available */
4075 for(i=0; i<numEvents; i++) {
4076 if (lpBuffer[i].EventType == KEY_EVENT) {
4077
4078 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4079 &(lpBuffer[i].Event);
4080 if (keyRecord->bKeyDown == TRUE) {
4081 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4082 curLength++;
4083 if (*keyPressed == '\r') {
4084 actualLength = curLength;
4085 }
4086 }
4087 }
4088 }
4089
4090 if(lpBuffer != NULL) {
4091 os::free(lpBuffer);
4092 }
4093
4094 *pbytes = (long) actualLength;
4095 return TRUE;
4096 }
4097
4098 // Map a block of memory.
4099 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
4100 char *addr, size_t bytes, bool read_only,
4101 bool allow_exec) {
4102 HANDLE hFile;
4103 char* base;
4104
4105 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4106 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4107 if (hFile == NULL) {
4108 if (PrintMiscellaneous && Verbose) {
4109 DWORD err = GetLastError();
4110 tty->print_cr("CreateFile() failed: GetLastError->%ld.");
4111 }
4112 return NULL;
4113 }
4114
4115 if (allow_exec) {
4116 // CreateFileMapping/MapViewOfFileEx can't map executable memory
4117 // unless it comes from a PE image (which the shared archive is not.)
4118 // Even VirtualProtect refuses to give execute access to mapped memory
4119 // that was not previously executable.
4120 //
4121 // Instead, stick the executable region in anonymous memory. Yuck.
4122 // Penalty is that ~4 pages will not be shareable - in the future
4123 // we might consider DLLizing the shared archive with a proper PE
4124 // header so that mapping executable + sharing is possible.
4125
4126 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4127 PAGE_READWRITE);
4128 if (base == NULL) {
4129 if (PrintMiscellaneous && Verbose) {
4130 DWORD err = GetLastError();
4131 tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4132 }
4133 CloseHandle(hFile);
4134 return NULL;
4135 }
4136
4137 DWORD bytes_read;
4138 OVERLAPPED overlapped;
4139 overlapped.Offset = (DWORD)file_offset;
4140 overlapped.OffsetHigh = 0;
4141 overlapped.hEvent = NULL;
4142 // ReadFile guarantees that if the return value is true, the requested
4143 // number of bytes were read before returning.
4144 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4145 if (!res) {
4146 if (PrintMiscellaneous && Verbose) {
4147 DWORD err = GetLastError();
4148 tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4149 }
4150 release_memory(base, bytes);
4151 CloseHandle(hFile);
4152 return NULL;
4153 }
4154 } else {
4155 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4156 NULL /*file_name*/);
4157 if (hMap == NULL) {
4158 if (PrintMiscellaneous && Verbose) {
4159 DWORD err = GetLastError();
4160 tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.");
4161 }
4162 CloseHandle(hFile);
4163 return NULL;
4164 }
4165
4166 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4167 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4168 (DWORD)bytes, addr);
4169 if (base == NULL) {
4170 if (PrintMiscellaneous && Verbose) {
4171 DWORD err = GetLastError();
4172 tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4173 }
4174 CloseHandle(hMap);
4175 CloseHandle(hFile);
4176 return NULL;
4177 }
4178
4179 if (CloseHandle(hMap) == 0) {
4180 if (PrintMiscellaneous && Verbose) {
4181 DWORD err = GetLastError();
4182 tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4183 }
4184 CloseHandle(hFile);
4185 return base;
4186 }
4187 }
4188
4189 if (allow_exec) {
4190 DWORD old_protect;
4191 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4192 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4193
4194 if (!res) {
4195 if (PrintMiscellaneous && Verbose) {
4196 DWORD err = GetLastError();
4197 tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4198 }
4199 // Don't consider this a hard error, on IA32 even if the
4200 // VirtualProtect fails, we should still be able to execute
4201 CloseHandle(hFile);
4202 return base;
4203 }
4204 }
4205
4206 if (CloseHandle(hFile) == 0) {
4207 if (PrintMiscellaneous && Verbose) {
4208 DWORD err = GetLastError();
4209 tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4210 }
4211 return base;
4212 }
4213
4214 return base;
4215 }
4216
4217
4218 // Remap a block of memory.
4219 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
4220 char *addr, size_t bytes, bool read_only,
4221 bool allow_exec) {
4222 // This OS does not allow existing memory maps to be remapped so we
4223 // have to unmap the memory before we remap it.
4224 if (!os::unmap_memory(addr, bytes)) {
4225 return NULL;
4226 }
4227
4228 // There is a very small theoretical window between the unmap_memory()
4229 // call above and the map_memory() call below where a thread in native
4230 // code may be able to access an address that is no longer mapped.
4231
4232 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4233 allow_exec);
4234 }
4235
4236
4237 // Unmap a block of memory.
4238 // Returns true=success, otherwise false.
4239
4240 bool os::unmap_memory(char* addr, size_t bytes) {
4241 BOOL result = UnmapViewOfFile(addr);
4242 if (result == 0) {
4243 if (PrintMiscellaneous && Verbose) {
4244 DWORD err = GetLastError();
4245 tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4246 }
4247 return false;
4248 }
4249 return true;
4250 }
4251
4252 void os::pause() {
4253 char filename[MAX_PATH];
4254 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4255 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4256 } else {
4257 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4258 }
4259
4260 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4261 if (fd != -1) {
4262 struct stat buf;
4263 ::close(fd);
4264 while (::stat(filename, &buf) == 0) {
4265 Sleep(100);
4266 }
4267 } else {
4268 jio_fprintf(stderr,
4269 "Could not open pause file '%s', continuing immediately.\n", filename);
4270 }
4271 }
4272
4273 // An Event wraps a win32 "CreateEvent" kernel handle.
4274 //
4275 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4276 //
4277 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4278 // field, and call CloseHandle() on the win32 event handle. Unpark() would
4279 // need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4280 // In addition, an unpark() operation might fetch the handle field, but the
4281 // event could recycle between the fetch and the SetEvent() operation.
4282 // SetEvent() would either fail because the handle was invalid, or inadvertently work,
4283 // as the win32 handle value had been recycled. In an ideal world calling SetEvent()
4284 // on an stale but recycled handle would be harmless, but in practice this might
4285 // confuse other non-Sun code, so it's not a viable approach.
4286 //
4287 // 2: Once a win32 event handle is associated with an Event, it remains associated
4288 // with the Event. The event handle is never closed. This could be construed
4289 // as handle leakage, but only up to the maximum # of threads that have been extant
4290 // at any one time. This shouldn't be an issue, as windows platforms typically
4291 // permit a process to have hundreds of thousands of open handles.
4292 //
4293 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4294 // and release unused handles.
4295 //
4296 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4297 // It's not clear, however, that we wouldn't be trading one type of leak for another.
4298 //
4299 // 5. Use an RCU-like mechanism (Read-Copy Update).
4300 // Or perhaps something similar to Maged Michael's "Hazard pointers".
4301 //
4302 // We use (2).
4303 //
4304 // TODO-FIXME:
4305 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4306 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4307 // to recover from (or at least detect) the dreaded Windows 841176 bug.
4308 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4309 // into a single win32 CreateEvent() handle.
4310 //
4311 // _Event transitions in park()
4312 // -1 => -1 : illegal
4313 // 1 => 0 : pass - return immediately
4314 // 0 => -1 : block
4315 //
4316 // _Event serves as a restricted-range semaphore :
4317 // -1 : thread is blocked
4318 // 0 : neutral - thread is running or ready
4319 // 1 : signaled - thread is running or ready
4320 //
4321 // Another possible encoding of _Event would be
4322 // with explicit "PARKED" and "SIGNALED" bits.
4323
4324 int os::PlatformEvent::park (jlong Millis) {
4325 guarantee (_ParkHandle != NULL , "Invariant") ;
4326 guarantee (Millis > 0 , "Invariant") ;
4327 int v ;
4328
4329 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4330 // the initial park() operation.
4331
4332 for (;;) {
4333 v = _Event ;
4334 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4335 }
4336 guarantee ((v == 0) || (v == 1), "invariant") ;
4337 if (v != 0) return OS_OK ;
4338
4339 // Do this the hard way by blocking ...
4340 // TODO: consider a brief spin here, gated on the success of recent
4341 // spin attempts by this thread.
4342 //
4343 // We decompose long timeouts into series of shorter timed waits.
4344 // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4345 // versions of Windows. See EventWait() for details. This may be superstition. Or not.
4346 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4347 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from
4348 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4349 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv ==
4350 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4351 // for the already waited time. This policy does not admit any new outcomes.
4352 // In the future, however, we might want to track the accumulated wait time and
4353 // adjust Millis accordingly if we encounter a spurious wakeup.
4354
4355 const int MAXTIMEOUT = 0x10000000 ;
4356 DWORD rv = WAIT_TIMEOUT ;
4357 while (_Event < 0 && Millis > 0) {
4358 DWORD prd = Millis ; // set prd = MAX (Millis, MAXTIMEOUT)
4359 if (Millis > MAXTIMEOUT) {
4360 prd = MAXTIMEOUT ;
4361 }
4362 rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4363 assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4364 if (rv == WAIT_TIMEOUT) {
4365 Millis -= prd ;
4366 }
4367 }
4368 v = _Event ;
4369 _Event = 0 ;
4370 OrderAccess::fence() ;
4371 // If we encounter a nearly simultanous timeout expiry and unpark()
4372 // we return OS_OK indicating we awoke via unpark().
4373 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
4374 return (v >= 0) ? OS_OK : OS_TIMEOUT ;
4375 }
4376
4377 void os::PlatformEvent::park () {
4378 guarantee (_ParkHandle != NULL, "Invariant") ;
4379 // Invariant: Only the thread associated with the Event/PlatformEvent
4380 // may call park().
4381 int v ;
4382 for (;;) {
4383 v = _Event ;
4384 if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4385 }
4386 guarantee ((v == 0) || (v == 1), "invariant") ;
4387 if (v != 0) return ;
4388
4389 // Do this the hard way by blocking ...
4390 // TODO: consider a brief spin here, gated on the success of recent
4391 // spin attempts by this thread.
4392 while (_Event < 0) {
4393 DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
4394 assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
4395 }
4396
4397 // Usually we'll find _Event == 0 at this point, but as
4398 // an optional optimization we clear it, just in case can
4399 // multiple unpark() operations drove _Event up to 1.
4400 _Event = 0 ;
4401 OrderAccess::fence() ;
4402 guarantee (_Event >= 0, "invariant") ;
4403 }
4404
4405 void os::PlatformEvent::unpark() {
4406 guarantee (_ParkHandle != NULL, "Invariant") ;
4407 int v ;
4408 for (;;) {
4409 v = _Event ; // Increment _Event if it's < 1.
4410 if (v > 0) {
4411 // If it's already signaled just return.
4412 // The LD of _Event could have reordered or be satisfied
4413 // by a read-aside from this processor's write buffer.
4414 // To avoid problems execute a barrier and then
4415 // ratify the value. A degenerate CAS() would also work.
4416 // Viz., CAS (v+0, &_Event, v) == v).
4417 OrderAccess::fence() ;
4418 if (_Event == v) return ;
4419 continue ;
4420 }
4421 if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
4422 }
4423 if (v < 0) {
4424 ::SetEvent (_ParkHandle) ;
4425 }
4426 }
4427
4428
4429 // JSR166
4430 // -------------------------------------------------------
4431
4432 /*
4433 * The Windows implementation of Park is very straightforward: Basic
4434 * operations on Win32 Events turn out to have the right semantics to
4435 * use them directly. We opportunistically resuse the event inherited
4436 * from Monitor.
4437 */
4438
4439
4440 void Parker::park(bool isAbsolute, jlong time) {
4441 guarantee (_ParkEvent != NULL, "invariant") ;
4442 // First, demultiplex/decode time arguments
4443 if (time < 0) { // don't wait
4444 return;
4445 }
4446 else if (time == 0 && !isAbsolute) {
4447 time = INFINITE;
4448 }
4449 else if (isAbsolute) {
4450 time -= os::javaTimeMillis(); // convert to relative time
4451 if (time <= 0) // already elapsed
4452 return;
4453 }
4454 else { // relative
4455 time /= 1000000; // Must coarsen from nanos to millis
4456 if (time == 0) // Wait for the minimal time unit if zero
4457 time = 1;
4458 }
4459
4460 JavaThread* thread = (JavaThread*)(Thread::current());
4461 assert(thread->is_Java_thread(), "Must be JavaThread");
4462 JavaThread *jt = (JavaThread *)thread;
4463
4464 // Don't wait if interrupted or already triggered
4465 if (Thread::is_interrupted(thread, false) ||
4466 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
4467 ResetEvent(_ParkEvent);
4468 return;
4469 }
4470 else {
4471 ThreadBlockInVM tbivm(jt);
4472 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4473 jt->set_suspend_equivalent();
4474
4475 WaitForSingleObject(_ParkEvent, time);
4476 ResetEvent(_ParkEvent);
4477
4478 // If externally suspended while waiting, re-suspend
4479 if (jt->handle_special_suspend_equivalent_condition()) {
4480 jt->java_suspend_self();
4481 }
4482 }
4483 }
4484
4485 void Parker::unpark() {
4486 guarantee (_ParkEvent != NULL, "invariant") ;
4487 SetEvent(_ParkEvent);
4488 }
4489
4490 // Run the specified command in a separate process. Return its exit value,
4491 // or -1 on failure (e.g. can't create a new process).
4492 int os::fork_and_exec(char* cmd) {
4493 STARTUPINFO si;
4494 PROCESS_INFORMATION pi;
4495
4496 memset(&si, 0, sizeof(si));
4497 si.cb = sizeof(si);
4498 memset(&pi, 0, sizeof(pi));
4499 BOOL rslt = CreateProcess(NULL, // executable name - use command line
4500 cmd, // command line
4501 NULL, // process security attribute
4502 NULL, // thread security attribute
4503 TRUE, // inherits system handles
4504 0, // no creation flags
4505 NULL, // use parent's environment block
4506 NULL, // use parent's starting directory
4507 &si, // (in) startup information
4508 &pi); // (out) process information
4509
4510 if (rslt) {
4511 // Wait until child process exits.
4512 WaitForSingleObject(pi.hProcess, INFINITE);
4513
4514 DWORD exit_code;
4515 GetExitCodeProcess(pi.hProcess, &exit_code);
4516
4517 // Close process and thread handles.
4518 CloseHandle(pi.hProcess);
4519 CloseHandle(pi.hThread);
4520
4521 return (int)exit_code;
4522 } else {
4523 return -1;
4524 }
4525 }
4526
4527 //--------------------------------------------------------------------------------------------------
4528 // Non-product code
4529
4530 static int mallocDebugIntervalCounter = 0;
4531 static int mallocDebugCounter = 0;
4532 bool os::check_heap(bool force) {
4533 if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
4534 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
4535 // Note: HeapValidate executes two hardware breakpoints when it finds something
4536 // wrong; at these points, eax contains the address of the offending block (I think).
4537 // To get to the exlicit error message(s) below, just continue twice.
4538 HANDLE heap = GetProcessHeap();
4539 { HeapLock(heap);
4540 PROCESS_HEAP_ENTRY phe;
4541 phe.lpData = NULL;
4542 while (HeapWalk(heap, &phe) != 0) {
4543 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
4544 !HeapValidate(heap, 0, phe.lpData)) {
4545 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
4546 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
4547 fatal("corrupted C heap");
4548 }
4549 }
4550 int err = GetLastError();
4551 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
4552 fatal(err_msg("heap walk aborted with error %d", err));
4553 }
4554 HeapUnlock(heap);
4555 }
4556 mallocDebugIntervalCounter = 0;
4557 }
4558 return true;
4559 }
4560
4561
4562 bool os::find(address addr, outputStream* st) {
4563 // Nothing yet
4564 return false;
4565 }
4566
4567 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
4568 DWORD exception_code = e->ExceptionRecord->ExceptionCode;
4569
4570 if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
4571 JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
4572 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
4573 address addr = (address) exceptionRecord->ExceptionInformation[1];
4574
4575 if (os::is_memory_serialize_page(thread, addr))
4576 return EXCEPTION_CONTINUE_EXECUTION;
4577 }
4578
4579 return EXCEPTION_CONTINUE_SEARCH;
4580 }
4581
4582 static int getLastErrorString(char *buf, size_t len)
4583 {
4584 long errval;
4585
4586 if ((errval = GetLastError()) != 0)
4587 {
4588 /* DOS error */
4589 size_t n = (size_t)FormatMessage(
4590 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
4591 NULL,
4592 errval,
4593 0,
4594 buf,
4595 (DWORD)len,
4596 NULL);
4597 if (n > 3) {
4598 /* Drop final '.', CR, LF */
4599 if (buf[n - 1] == '\n') n--;
4600 if (buf[n - 1] == '\r') n--;
4601 if (buf[n - 1] == '.') n--;
4602 buf[n] = '\0';
4603 }
4604 return (int)n;
4605 }
4606
4607 if (errno != 0)
4608 {
4609 /* C runtime error that has no corresponding DOS error code */
4610 const char *s = strerror(errno);
4611 size_t n = strlen(s);
4612 if (n >= len) n = len - 1;
4613 strncpy(buf, s, n);
4614 buf[n] = '\0';
4615 return (int)n;
4616 }
4617 return 0;
4618 }
4619
4620
4621 // We don't build a headless jre for Windows
4622 bool os::is_headless_jre() { return false; }
4623
4624
4625 typedef CRITICAL_SECTION mutex_t;
4626 #define mutexInit(m) InitializeCriticalSection(m)
4627 #define mutexDestroy(m) DeleteCriticalSection(m)
4628 #define mutexLock(m) EnterCriticalSection(m)
4629 #define mutexUnlock(m) LeaveCriticalSection(m)
4630
4631 static bool sock_initialized = FALSE;
4632 static mutex_t sockFnTableMutex;
4633
4634 static void initSock() {
4635 WSADATA wsadata;
4636
4637 if (!os::WinSock2Dll::WinSock2Available()) {
4638 jio_fprintf(stderr, "Could not load Winsock 2 (error: %d)\n",
4639 ::GetLastError());
4640 return;
4641 }
4642 if (sock_initialized == TRUE) return;
4643
4644 ::mutexInit(&sockFnTableMutex);
4645 ::mutexLock(&sockFnTableMutex);
4646 if (os::WinSock2Dll::WSAStartup(MAKEWORD(1,1), &wsadata) != 0) {
4647 jio_fprintf(stderr, "Could not initialize Winsock\n");
4648 }
4649 sock_initialized = TRUE;
4650 ::mutexUnlock(&sockFnTableMutex);
4651 }
4652
4653 struct hostent* os::get_host_by_name(char* name) {
4654 if (!sock_initialized) {
4655 initSock();
4656 }
4657 if (!os::WinSock2Dll::WinSock2Available()) {
4658 return NULL;
4659 }
4660 return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
4661 }
4662
4663
4664 int os::socket_close(int fd) {
4665 ShouldNotReachHere();
4666 return 0;
4667 }
4668
4669 int os::socket_available(int fd, jint *pbytes) {
4670 ShouldNotReachHere();
4671 return 0;
4672 }
4673
4674 int os::socket(int domain, int type, int protocol) {
4675 ShouldNotReachHere();
4676 return 0;
4677 }
4678
4679 int os::listen(int fd, int count) {
4680 ShouldNotReachHere();
4681 return 0;
4682 }
4683
4684 int os::connect(int fd, struct sockaddr *him, int len) {
4685 ShouldNotReachHere();
4686 return 0;
4687 }
4688
4689 int os::accept(int fd, struct sockaddr *him, int *len) {
4690 ShouldNotReachHere();
4691 return 0;
4692 }
4693
4694 int os::sendto(int fd, char *buf, int len, int flags,
4695 struct sockaddr *to, int tolen) {
4696 ShouldNotReachHere();
4697 return 0;
4698 }
4699
4700 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
4701 sockaddr *from, int *fromlen) {
4702 ShouldNotReachHere();
4703 return 0;
4704 }
4705
4706 int os::recv(int fd, char *buf, int nBytes, int flags) {
4707 ShouldNotReachHere();
4708 return 0;
4709 }
4710
4711 int os::send(int fd, char *buf, int nBytes, int flags) {
4712 ShouldNotReachHere();
4713 return 0;
4714 }
4715
4716 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
4717 ShouldNotReachHere();
4718 return 0;
4719 }
4720
4721 int os::timeout(int fd, long timeout) {
4722 ShouldNotReachHere();
4723 return 0;
4724 }
4725
4726 int os::get_host_name(char* name, int namelen) {
4727 ShouldNotReachHere();
4728 return 0;
4729 }
4730
4731 int os::socket_shutdown(int fd, int howto) {
4732 ShouldNotReachHere();
4733 return 0;
4734 }
4735
4736 int os::bind(int fd, struct sockaddr *him, int len) {
4737 ShouldNotReachHere();
4738 return 0;
4739 }
4740
4741 int os::get_sock_name(int fd, struct sockaddr *him, int *len) {
4742 ShouldNotReachHere();
4743 return 0;
4744 }
4745
4746 int os::get_sock_opt(int fd, int level, int optname,
4747 char *optval, int* optlen) {
4748 ShouldNotReachHere();
4749 return 0;
4750 }
4751
4752 int os::set_sock_opt(int fd, int level, int optname,
4753 const char *optval, int optlen) {
4754 ShouldNotReachHere();
4755 return 0;
4756 }
4757
4758
4759 // Kernel32 API
4760 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
4761 GetLargePageMinimum_Fn os::Kernel32Dll::_GetLargePageMinimum = NULL;
4762 BOOL os::Kernel32Dll::initialized = FALSE;
4763 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
4764 assert(initialized && _GetLargePageMinimum != NULL,
4765 "GetLargePageMinimumAvailable() not yet called");
4766 return _GetLargePageMinimum();
4767 }
4768
4769 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
4770 if (!initialized) {
4771 initialize();
4772 }
4773 return _GetLargePageMinimum != NULL;
4774 }
4775
4776
4777 #ifndef JDK6_OR_EARLIER
4778
4779 void os::Kernel32Dll::initialize() {
4780 if (!initialized) {
4781 HMODULE handle = ::GetModuleHandle("Kernel32.dll");
4782 assert(handle != NULL, "Just check");
4783 _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
4784 initialized = TRUE;
4785 }
4786 }
4787
4788
4789 // Kernel32 API
4790 inline BOOL os::Kernel32Dll::SwitchToThread() {
4791 return ::SwitchToThread();
4792 }
4793
4794 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
4795 return true;
4796 }
4797
4798 // Help tools
4799 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
4800 return true;
4801 }
4802
4803 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
4804 return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
4805 }
4806
4807 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
4808 return ::Module32First(hSnapshot, lpme);
4809 }
4810
4811 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
4812 return ::Module32Next(hSnapshot, lpme);
4813 }
4814
4815
4816 inline BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
4817 return true;
4818 }
4819
4820 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
4821 ::GetNativeSystemInfo(lpSystemInfo);
4822 }
4823
4824 // PSAPI API
4825 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
4826 return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
4827 }
4828
4829 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
4830 return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
4831 }
4832
4833 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
4834 return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
4835 }
4836
4837 inline BOOL os::PSApiDll::PSApiAvailable() {
4838 return true;
4839 }
4840
4841
4842 // WinSock2 API
4843 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
4844 return ::WSAStartup(wVersionRequested, lpWSAData);
4845 }
4846
4847 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
4848 return ::gethostbyname(name);
4849 }
4850
4851 inline BOOL os::WinSock2Dll::WinSock2Available() {
4852 return true;
4853 }
4854
4855 // Advapi API
4856 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
4857 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
4858 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
4859 return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
4860 BufferLength, PreviousState, ReturnLength);
4861 }
4862
4863 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
4864 PHANDLE TokenHandle) {
4865 return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
4866 }
4867
4868 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
4869 return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
4870 }
4871
4872 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
4873 return true;
4874 }
4875
4876 #else
4877 // Kernel32 API
4878 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
4879 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
4880 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
4881 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
4882 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
4883
4884 SwitchToThread_Fn os::Kernel32Dll::_SwitchToThread = NULL;
4885 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
4886 Module32First_Fn os::Kernel32Dll::_Module32First = NULL;
4887 Module32Next_Fn os::Kernel32Dll::_Module32Next = NULL;
4888 GetNativeSystemInfo_Fn os::Kernel32Dll::_GetNativeSystemInfo = NULL;
4889
4890 void os::Kernel32Dll::initialize() {
4891 if (!initialized) {
4892 HMODULE handle = ::GetModuleHandle("Kernel32.dll");
4893 assert(handle != NULL, "Just check");
4894
4895 _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
4896 _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
4897 _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
4898 ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
4899 _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
4900 _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
4901 _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
4902
4903 initialized = TRUE;
4904 }
4905 }
4906
4907 BOOL os::Kernel32Dll::SwitchToThread() {
4908 assert(initialized && _SwitchToThread != NULL,
4909 "SwitchToThreadAvailable() not yet called");
4910 return _SwitchToThread();
4911 }
4912
4913
4914 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
4915 if (!initialized) {
4916 initialize();
4917 }
4918 return _SwitchToThread != NULL;
4919 }
4920
4921 // Help tools
4922 BOOL os::Kernel32Dll::HelpToolsAvailable() {
4923 if (!initialized) {
4924 initialize();
4925 }
4926 return _CreateToolhelp32Snapshot != NULL &&
4927 _Module32First != NULL &&
4928 _Module32Next != NULL;
4929 }
4930
4931 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
4932 assert(initialized && _CreateToolhelp32Snapshot != NULL,
4933 "HelpToolsAvailable() not yet called");
4934
4935 return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
4936 }
4937
4938 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
4939 assert(initialized && _Module32First != NULL,
4940 "HelpToolsAvailable() not yet called");
4941
4942 return _Module32First(hSnapshot, lpme);
4943 }
4944
4945 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
4946 assert(initialized && _Module32Next != NULL,
4947 "HelpToolsAvailable() not yet called");
4948
4949 return _Module32Next(hSnapshot, lpme);
4950 }
4951
4952
4953 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
4954 if (!initialized) {
4955 initialize();
4956 }
4957 return _GetNativeSystemInfo != NULL;
4958 }
4959
4960 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
4961 assert(initialized && _GetNativeSystemInfo != NULL,
4962 "GetNativeSystemInfoAvailable() not yet called");
4963
4964 _GetNativeSystemInfo(lpSystemInfo);
4965 }
4966
4967 // PSAPI API
4968
4969
4970 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
4971 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
4972 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
4973
4974 EnumProcessModules_Fn os::PSApiDll::_EnumProcessModules = NULL;
4975 GetModuleFileNameEx_Fn os::PSApiDll::_GetModuleFileNameEx = NULL;
4976 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
4977 BOOL os::PSApiDll::initialized = FALSE;
4978
4979 void os::PSApiDll::initialize() {
4980 if (!initialized) {
4981 HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
4982 if (handle != NULL) {
4983 _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
4984 "EnumProcessModules");
4985 _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
4986 "GetModuleFileNameExA");
4987 _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
4988 "GetModuleInformation");
4989 }
4990 initialized = TRUE;
4991 }
4992 }
4993
4994
4995
4996 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
4997 assert(initialized && _EnumProcessModules != NULL,
4998 "PSApiAvailable() not yet called");
4999 return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5000 }
5001
5002 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5003 assert(initialized && _GetModuleFileNameEx != NULL,
5004 "PSApiAvailable() not yet called");
5005 return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5006 }
5007
5008 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5009 assert(initialized && _GetModuleInformation != NULL,
5010 "PSApiAvailable() not yet called");
5011 return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5012 }
5013
5014 BOOL os::PSApiDll::PSApiAvailable() {
5015 if (!initialized) {
5016 initialize();
5017 }
5018 return _EnumProcessModules != NULL &&
5019 _GetModuleFileNameEx != NULL &&
5020 _GetModuleInformation != NULL;
5021 }
5022
5023
5024 // WinSock2 API
5025 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5026 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5027
5028 WSAStartup_Fn os::WinSock2Dll::_WSAStartup = NULL;
5029 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5030 BOOL os::WinSock2Dll::initialized = FALSE;
5031
5032 void os::WinSock2Dll::initialize() {
5033 if (!initialized) {
5034 HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5035 if (handle != NULL) {
5036 _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5037 _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5038 }
5039 initialized = TRUE;
5040 }
5041 }
5042
5043
5044 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5045 assert(initialized && _WSAStartup != NULL,
5046 "WinSock2Available() not yet called");
5047 return _WSAStartup(wVersionRequested, lpWSAData);
5048 }
5049
5050 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5051 assert(initialized && _gethostbyname != NULL,
5052 "WinSock2Available() not yet called");
5053 return _gethostbyname(name);
5054 }
5055
5056 BOOL os::WinSock2Dll::WinSock2Available() {
5057 if (!initialized) {
5058 initialize();
5059 }
5060 return _WSAStartup != NULL &&
5061 _gethostbyname != NULL;
5062 }
5063
5064 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5065 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5066 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5067
5068 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5069 OpenProcessToken_Fn os::Advapi32Dll::_OpenProcessToken = NULL;
5070 LookupPrivilegeValue_Fn os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5071 BOOL os::Advapi32Dll::initialized = FALSE;
5072
5073 void os::Advapi32Dll::initialize() {
5074 if (!initialized) {
5075 HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5076 if (handle != NULL) {
5077 _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5078 "AdjustTokenPrivileges");
5079 _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5080 "OpenProcessToken");
5081 _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5082 "LookupPrivilegeValueA");
5083 }
5084 initialized = TRUE;
5085 }
5086 }
5087
5088 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5089 BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5090 PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5091 assert(initialized && _AdjustTokenPrivileges != NULL,
5092 "AdvapiAvailable() not yet called");
5093 return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5094 BufferLength, PreviousState, ReturnLength);
5095 }
5096
5097 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5098 PHANDLE TokenHandle) {
5099 assert(initialized && _OpenProcessToken != NULL,
5100 "AdvapiAvailable() not yet called");
5101 return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5102 }
5103
5104 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5105 assert(initialized && _LookupPrivilegeValue != NULL,
5106 "AdvapiAvailable() not yet called");
5107 return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5108 }
5109
5110 BOOL os::Advapi32Dll::AdvapiAvailable() {
5111 if (!initialized) {
5112 initialize();
5113 }
5114 return _AdjustTokenPrivileges != NULL &&
5115 _OpenProcessToken != NULL &&
5116 _LookupPrivilegeValue != NULL;
5117 }
5118
5119 #endif
5120