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