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 stringStream ss(buf, buflen);
548 if (stacksize == 0) {
549 ss.print("stacksize: default, ");
550 } else {
551 ss.print("stacksize: " SIZE_FORMAT "k, ", stacksize / 1024);
552 }
553 ss.print("flags: ");
554 #define PRINT_FLAG(f) if (initflag & f) ss.print( #f " ");
555 #define ALL(X) \
556 X(CREATE_SUSPENDED) \
557 X(STACK_SIZE_PARAM_IS_A_RESERVATION)
558 ALL(PRINT_FLAG)
559 #undef ALL
560 #undef PRINT_FLAG
561 return buf;
562 }
563
564 // Allocate and initialize a new OSThread
565 bool os::create_thread(Thread* thread, ThreadType thr_type,
566 size_t stack_size) {
567 unsigned thread_id;
568
569 // Allocate the OSThread object
570 OSThread* osthread = new OSThread(NULL, NULL);
571 if (osthread == NULL) {
572 return false;
573 }
574
575 // Initialize support for Java interrupts
576 HANDLE interrupt_event = CreateEvent(NULL, true, false, NULL);
577 if (interrupt_event == NULL) {
578 delete osthread;
579 return NULL;
580 }
581 osthread->set_interrupt_event(interrupt_event);
582 osthread->set_interrupted(false);
583
584 thread->set_osthread(osthread);
585
586 if (stack_size == 0) {
587 switch (thr_type) {
588 case os::java_thread:
589 // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
590 if (JavaThread::stack_size_at_create() > 0) {
591 stack_size = JavaThread::stack_size_at_create();
592 }
593 break;
594 case os::compiler_thread:
595 if (CompilerThreadStackSize > 0) {
596 stack_size = (size_t)(CompilerThreadStackSize * K);
597 break;
598 } // else fall through:
599 // use VMThreadStackSize if CompilerThreadStackSize is not defined
600 case os::vm_thread:
601 case os::pgc_thread:
602 case os::cgc_thread:
603 case os::watcher_thread:
604 if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
605 break;
606 }
607 }
608
609 // Create the Win32 thread
610 //
611 // Contrary to what MSDN document says, "stack_size" in _beginthreadex()
612 // does not specify stack size. Instead, it specifies the size of
613 // initially committed space. The stack size is determined by
614 // PE header in the executable. If the committed "stack_size" is larger
615 // than default value in the PE header, the stack is rounded up to the
616 // nearest multiple of 1MB. For example if the launcher has default
617 // stack size of 320k, specifying any size less than 320k does not
618 // affect the actual stack size at all, it only affects the initial
619 // commitment. On the other hand, specifying 'stack_size' larger than
620 // default value may cause significant increase in memory usage, because
621 // not only the stack space will be rounded up to MB, but also the
622 // entire space is committed upfront.
623 //
624 // Finally Windows XP added a new flag 'STACK_SIZE_PARAM_IS_A_RESERVATION'
625 // for CreateThread() that can treat 'stack_size' as stack size. However we
626 // are not supposed to call CreateThread() directly according to MSDN
627 // document because JVM uses C runtime library. The good news is that the
628 // flag appears to work with _beginthredex() as well.
629
630 const unsigned initflag = CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION;
631 HANDLE thread_handle =
632 (HANDLE)_beginthreadex(NULL,
633 (unsigned)stack_size,
634 (unsigned (__stdcall *)(void*)) java_start,
635 thread,
636 initflag,
637 &thread_id);
638
639 char buf[64];
640 if (thread_handle != NULL) {
641 log_info(os, thread)("Thread started (tid: %u, attributes: %s)",
642 thread_id, describe_beginthreadex_attributes(buf, sizeof(buf), stack_size, initflag));
643 } else {
644 log_warning(os, thread)("Failed to start thread - _beginthreadex failed (%s) for attributes: %s.",
645 os::errno_name(errno), describe_beginthreadex_attributes(buf, sizeof(buf), stack_size, initflag));
646 }
647
648 if (thread_handle == NULL) {
649 // Need to clean up stuff we've allocated so far
650 CloseHandle(osthread->interrupt_event());
651 thread->set_osthread(NULL);
652 delete osthread;
653 return NULL;
654 }
655
656 Atomic::inc_ptr((intptr_t*)&os::win32::_os_thread_count);
657
658 // Store info on the Win32 thread into the OSThread
659 osthread->set_thread_handle(thread_handle);
660 osthread->set_thread_id(thread_id);
661
662 // Initial thread state is INITIALIZED, not SUSPENDED
663 osthread->set_state(INITIALIZED);
664
665 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
666 return true;
667 }
668
669
670 // Free Win32 resources related to the OSThread
671 void os::free_thread(OSThread* osthread) {
672 assert(osthread != NULL, "osthread not set");
673 CloseHandle(osthread->thread_handle());
674 CloseHandle(osthread->interrupt_event());
675 delete osthread;
676 }
677
678 static jlong first_filetime;
679 static jlong initial_performance_count;
680 static jlong performance_frequency;
681
682
683 jlong as_long(LARGE_INTEGER x) {
684 jlong result = 0; // initialization to avoid warning
685 set_high(&result, x.HighPart);
686 set_low(&result, x.LowPart);
687 return result;
688 }
689
690
691 jlong os::elapsed_counter() {
692 LARGE_INTEGER count;
693 QueryPerformanceCounter(&count);
694 return as_long(count) - initial_performance_count;
695 }
696
697
698 jlong os::elapsed_frequency() {
699 return performance_frequency;
700 }
701
702
703 julong os::available_memory() {
704 return win32::available_memory();
705 }
706
707 julong os::win32::available_memory() {
708 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
709 // value if total memory is larger than 4GB
710 MEMORYSTATUSEX ms;
711 ms.dwLength = sizeof(ms);
712 GlobalMemoryStatusEx(&ms);
713
714 return (julong)ms.ullAvailPhys;
715 }
716
717 julong os::physical_memory() {
718 return win32::physical_memory();
719 }
720
721 bool os::has_allocatable_memory_limit(julong* limit) {
722 MEMORYSTATUSEX ms;
723 ms.dwLength = sizeof(ms);
724 GlobalMemoryStatusEx(&ms);
725 #ifdef _LP64
726 *limit = (julong)ms.ullAvailVirtual;
727 return true;
728 #else
729 // Limit to 1400m because of the 2gb address space wall
730 *limit = MIN2((julong)1400*M, (julong)ms.ullAvailVirtual);
731 return true;
732 #endif
733 }
734
735 int os::active_processor_count() {
736 DWORD_PTR lpProcessAffinityMask = 0;
737 DWORD_PTR lpSystemAffinityMask = 0;
738 int proc_count = processor_count();
739 if (proc_count <= sizeof(UINT_PTR) * BitsPerByte &&
740 GetProcessAffinityMask(GetCurrentProcess(), &lpProcessAffinityMask, &lpSystemAffinityMask)) {
741 // Nof active processors is number of bits in process affinity mask
742 int bitcount = 0;
743 while (lpProcessAffinityMask != 0) {
744 lpProcessAffinityMask = lpProcessAffinityMask & (lpProcessAffinityMask-1);
745 bitcount++;
746 }
747 return bitcount;
748 } else {
749 return proc_count;
750 }
751 }
752
753 void os::set_native_thread_name(const char *name) {
754
755 // See: http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx
756 //
757 // Note that unfortunately this only works if the process
758 // is already attached to a debugger; debugger must observe
759 // the exception below to show the correct name.
760
761 const DWORD MS_VC_EXCEPTION = 0x406D1388;
762 struct {
763 DWORD dwType; // must be 0x1000
764 LPCSTR szName; // pointer to name (in user addr space)
765 DWORD dwThreadID; // thread ID (-1=caller thread)
766 DWORD dwFlags; // reserved for future use, must be zero
767 } info;
768
769 info.dwType = 0x1000;
770 info.szName = name;
771 info.dwThreadID = -1;
772 info.dwFlags = 0;
773
774 __try {
775 RaiseException (MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(DWORD), (const ULONG_PTR*)&info );
776 } __except(EXCEPTION_CONTINUE_EXECUTION) {}
777 }
778
779 bool os::distribute_processes(uint length, uint* distribution) {
780 // Not yet implemented.
781 return false;
782 }
783
784 bool os::bind_to_processor(uint processor_id) {
785 // Not yet implemented.
786 return false;
787 }
788
789 void os::win32::initialize_performance_counter() {
790 LARGE_INTEGER count;
791 QueryPerformanceFrequency(&count);
792 performance_frequency = as_long(count);
793 QueryPerformanceCounter(&count);
794 initial_performance_count = as_long(count);
795 }
796
797
798 double os::elapsedTime() {
799 return (double) elapsed_counter() / (double) elapsed_frequency();
800 }
801
802
803 // Windows format:
804 // The FILETIME structure is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601.
805 // Java format:
806 // Java standards require the number of milliseconds since 1/1/1970
807
808 // Constant offset - calculated using offset()
809 static jlong _offset = 116444736000000000;
810 // Fake time counter for reproducible results when debugging
811 static jlong fake_time = 0;
812
813 #ifdef ASSERT
814 // Just to be safe, recalculate the offset in debug mode
815 static jlong _calculated_offset = 0;
816 static int _has_calculated_offset = 0;
817
818 jlong offset() {
819 if (_has_calculated_offset) return _calculated_offset;
820 SYSTEMTIME java_origin;
821 java_origin.wYear = 1970;
822 java_origin.wMonth = 1;
823 java_origin.wDayOfWeek = 0; // ignored
824 java_origin.wDay = 1;
825 java_origin.wHour = 0;
826 java_origin.wMinute = 0;
827 java_origin.wSecond = 0;
828 java_origin.wMilliseconds = 0;
829 FILETIME jot;
830 if (!SystemTimeToFileTime(&java_origin, &jot)) {
831 fatal("Error = %d\nWindows error", GetLastError());
832 }
833 _calculated_offset = jlong_from(jot.dwHighDateTime, jot.dwLowDateTime);
834 _has_calculated_offset = 1;
835 assert(_calculated_offset == _offset, "Calculated and constant time offsets must be equal");
836 return _calculated_offset;
837 }
838 #else
839 jlong offset() {
840 return _offset;
841 }
842 #endif
843
844 jlong windows_to_java_time(FILETIME wt) {
845 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
846 return (a - offset()) / 10000;
847 }
848
849 // Returns time ticks in (10th of micro seconds)
850 jlong windows_to_time_ticks(FILETIME wt) {
851 jlong a = jlong_from(wt.dwHighDateTime, wt.dwLowDateTime);
852 return (a - offset());
853 }
854
855 FILETIME java_to_windows_time(jlong l) {
856 jlong a = (l * 10000) + offset();
857 FILETIME result;
858 result.dwHighDateTime = high(a);
859 result.dwLowDateTime = low(a);
860 return result;
861 }
862
863 bool os::supports_vtime() { return true; }
864 bool os::enable_vtime() { return false; }
865 bool os::vtime_enabled() { return false; }
866
867 double os::elapsedVTime() {
868 FILETIME created;
869 FILETIME exited;
870 FILETIME kernel;
871 FILETIME user;
872 if (GetThreadTimes(GetCurrentThread(), &created, &exited, &kernel, &user) != 0) {
873 // the resolution of windows_to_java_time() should be sufficient (ms)
874 return (double) (windows_to_java_time(kernel) + windows_to_java_time(user)) / MILLIUNITS;
875 } else {
876 return elapsedTime();
877 }
878 }
879
880 jlong os::javaTimeMillis() {
881 if (UseFakeTimers) {
882 return fake_time++;
883 } else {
884 FILETIME wt;
885 GetSystemTimeAsFileTime(&wt);
886 return windows_to_java_time(wt);
887 }
888 }
889
890 void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
891 FILETIME wt;
892 GetSystemTimeAsFileTime(&wt);
893 jlong ticks = windows_to_time_ticks(wt); // 10th of micros
894 jlong secs = jlong(ticks / 10000000); // 10000 * 1000
895 seconds = secs;
896 nanos = jlong(ticks - (secs*10000000)) * 100;
897 }
898
899 jlong os::javaTimeNanos() {
900 LARGE_INTEGER current_count;
901 QueryPerformanceCounter(¤t_count);
902 double current = as_long(current_count);
903 double freq = performance_frequency;
904 jlong time = (jlong)((current/freq) * NANOSECS_PER_SEC);
905 return time;
906 }
907
908 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
909 jlong freq = performance_frequency;
910 if (freq < NANOSECS_PER_SEC) {
911 // the performance counter is 64 bits and we will
912 // be multiplying it -- so no wrap in 64 bits
913 info_ptr->max_value = ALL_64_BITS;
914 } else if (freq > NANOSECS_PER_SEC) {
915 // use the max value the counter can reach to
916 // determine the max value which could be returned
917 julong max_counter = (julong)ALL_64_BITS;
918 info_ptr->max_value = (jlong)(max_counter / (freq / NANOSECS_PER_SEC));
919 } else {
920 // the performance counter is 64 bits and we will
921 // be using it directly -- so no wrap in 64 bits
922 info_ptr->max_value = ALL_64_BITS;
923 }
924
925 // using a counter, so no skipping
926 info_ptr->may_skip_backward = false;
927 info_ptr->may_skip_forward = false;
928
929 info_ptr->kind = JVMTI_TIMER_ELAPSED; // elapsed not CPU time
930 }
931
932 char* os::local_time_string(char *buf, size_t buflen) {
933 SYSTEMTIME st;
934 GetLocalTime(&st);
935 jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
936 st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
937 return buf;
938 }
939
940 bool os::getTimesSecs(double* process_real_time,
941 double* process_user_time,
942 double* process_system_time) {
943 HANDLE h_process = GetCurrentProcess();
944 FILETIME create_time, exit_time, kernel_time, user_time;
945 BOOL result = GetProcessTimes(h_process,
946 &create_time,
947 &exit_time,
948 &kernel_time,
949 &user_time);
950 if (result != 0) {
951 FILETIME wt;
952 GetSystemTimeAsFileTime(&wt);
953 jlong rtc_millis = windows_to_java_time(wt);
954 *process_real_time = ((double) rtc_millis) / ((double) MILLIUNITS);
955 *process_user_time =
956 (double) jlong_from(user_time.dwHighDateTime, user_time.dwLowDateTime) / (10 * MICROUNITS);
957 *process_system_time =
958 (double) jlong_from(kernel_time.dwHighDateTime, kernel_time.dwLowDateTime) / (10 * MICROUNITS);
959 return true;
960 } else {
961 return false;
962 }
963 }
964
965 void os::shutdown() {
966 // allow PerfMemory to attempt cleanup of any persistent resources
967 perfMemory_exit();
968
969 // flush buffered output, finish log files
970 ostream_abort();
971
972 // Check for abort hook
973 abort_hook_t abort_hook = Arguments::abort_hook();
974 if (abort_hook != NULL) {
975 abort_hook();
976 }
977 }
978
979
980 static BOOL (WINAPI *_MiniDumpWriteDump)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
981 PMINIDUMP_EXCEPTION_INFORMATION,
982 PMINIDUMP_USER_STREAM_INFORMATION,
983 PMINIDUMP_CALLBACK_INFORMATION);
984
985 static HANDLE dumpFile = NULL;
986
987 // Check if dump file can be created.
988 void os::check_dump_limit(char* buffer, size_t buffsz) {
989 bool status = true;
990 if (!FLAG_IS_DEFAULT(CreateCoredumpOnCrash) && !CreateCoredumpOnCrash) {
991 jio_snprintf(buffer, buffsz, "CreateCoredumpOnCrash is disabled from command line");
992 status = false;
993 }
994
995 #ifndef ASSERT
996 if (!os::win32::is_windows_server() && FLAG_IS_DEFAULT(CreateCoredumpOnCrash)) {
997 jio_snprintf(buffer, buffsz, "Minidumps are not enabled by default on client versions of Windows");
998 status = false;
999 }
1000 #endif
1001
1002 if (status) {
1003 const char* cwd = get_current_directory(NULL, 0);
1004 int pid = current_process_id();
1005 if (cwd != NULL) {
1006 jio_snprintf(buffer, buffsz, "%s\\hs_err_pid%u.mdmp", cwd, pid);
1007 } else {
1008 jio_snprintf(buffer, buffsz, ".\\hs_err_pid%u.mdmp", pid);
1009 }
1010
1011 if (dumpFile == NULL &&
1012 (dumpFile = CreateFile(buffer, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL))
1013 == INVALID_HANDLE_VALUE) {
1014 jio_snprintf(buffer, buffsz, "Failed to create minidump file (0x%x).", GetLastError());
1015 status = false;
1016 }
1017 }
1018 VMError::record_coredump_status(buffer, status);
1019 }
1020
1021 void os::abort(bool dump_core, void* siginfo, const void* context) {
1022 HINSTANCE dbghelp;
1023 EXCEPTION_POINTERS ep;
1024 MINIDUMP_EXCEPTION_INFORMATION mei;
1025 MINIDUMP_EXCEPTION_INFORMATION* pmei;
1026
1027 HANDLE hProcess = GetCurrentProcess();
1028 DWORD processId = GetCurrentProcessId();
1029 MINIDUMP_TYPE dumpType;
1030
1031 shutdown();
1032 if (!dump_core || dumpFile == NULL) {
1033 if (dumpFile != NULL) {
1034 CloseHandle(dumpFile);
1035 }
1036 win32::exit_process_or_thread(win32::EPT_PROCESS, 1);
1037 }
1038
1039 dbghelp = os::win32::load_Windows_dll("DBGHELP.DLL", NULL, 0);
1040
1041 if (dbghelp == NULL) {
1042 jio_fprintf(stderr, "Failed to load dbghelp.dll\n");
1043 CloseHandle(dumpFile);
1044 win32::exit_process_or_thread(win32::EPT_PROCESS, 1);
1045 }
1046
1047 _MiniDumpWriteDump =
1048 CAST_TO_FN_PTR(BOOL(WINAPI *)(HANDLE, DWORD, HANDLE, MINIDUMP_TYPE,
1049 PMINIDUMP_EXCEPTION_INFORMATION,
1050 PMINIDUMP_USER_STREAM_INFORMATION,
1051 PMINIDUMP_CALLBACK_INFORMATION),
1052 GetProcAddress(dbghelp,
1053 "MiniDumpWriteDump"));
1054
1055 if (_MiniDumpWriteDump == NULL) {
1056 jio_fprintf(stderr, "Failed to find MiniDumpWriteDump() in module dbghelp.dll.\n");
1057 CloseHandle(dumpFile);
1058 win32::exit_process_or_thread(win32::EPT_PROCESS, 1);
1059 }
1060
1061 dumpType = (MINIDUMP_TYPE)(MiniDumpWithFullMemory | MiniDumpWithHandleData |
1062 MiniDumpWithFullMemoryInfo | MiniDumpWithThreadInfo | MiniDumpWithUnloadedModules);
1063
1064 if (siginfo != NULL && context != NULL) {
1065 ep.ContextRecord = (PCONTEXT) context;
1066 ep.ExceptionRecord = (PEXCEPTION_RECORD) siginfo;
1067
1068 mei.ThreadId = GetCurrentThreadId();
1069 mei.ExceptionPointers = &ep;
1070 pmei = &mei;
1071 } else {
1072 pmei = NULL;
1073 }
1074
1075 // Older versions of dbghelp.dll (the one shipped with Win2003 for example) may not support all
1076 // the dump types we really want. If first call fails, lets fall back to just use MiniDumpWithFullMemory then.
1077 if (_MiniDumpWriteDump(hProcess, processId, dumpFile, dumpType, pmei, NULL, NULL) == false &&
1078 _MiniDumpWriteDump(hProcess, processId, dumpFile, (MINIDUMP_TYPE)MiniDumpWithFullMemory, pmei, NULL, NULL) == false) {
1079 jio_fprintf(stderr, "Call to MiniDumpWriteDump() failed (Error 0x%x)\n", GetLastError());
1080 }
1081 CloseHandle(dumpFile);
1082 win32::exit_process_or_thread(win32::EPT_PROCESS, 1);
1083 }
1084
1085 // Die immediately, no exit hook, no abort hook, no cleanup.
1086 void os::die() {
1087 win32::exit_process_or_thread(win32::EPT_PROCESS_DIE, -1);
1088 }
1089
1090 // Directory routines copied from src/win32/native/java/io/dirent_md.c
1091 // * dirent_md.c 1.15 00/02/02
1092 //
1093 // The declarations for DIR and struct dirent are in jvm_win32.h.
1094
1095 // Caller must have already run dirname through JVM_NativePath, which removes
1096 // duplicate slashes and converts all instances of '/' into '\\'.
1097
1098 DIR * os::opendir(const char *dirname) {
1099 assert(dirname != NULL, "just checking"); // hotspot change
1100 DIR *dirp = (DIR *)malloc(sizeof(DIR), mtInternal);
1101 DWORD fattr; // hotspot change
1102 char alt_dirname[4] = { 0, 0, 0, 0 };
1103
1104 if (dirp == 0) {
1105 errno = ENOMEM;
1106 return 0;
1107 }
1108
1109 // Win32 accepts "\" in its POSIX stat(), but refuses to treat it
1110 // as a directory in FindFirstFile(). We detect this case here and
1111 // prepend the current drive name.
1112 //
1113 if (dirname[1] == '\0' && dirname[0] == '\\') {
1114 alt_dirname[0] = _getdrive() + 'A' - 1;
1115 alt_dirname[1] = ':';
1116 alt_dirname[2] = '\\';
1117 alt_dirname[3] = '\0';
1118 dirname = alt_dirname;
1119 }
1120
1121 dirp->path = (char *)malloc(strlen(dirname) + 5, mtInternal);
1122 if (dirp->path == 0) {
1123 free(dirp);
1124 errno = ENOMEM;
1125 return 0;
1126 }
1127 strcpy(dirp->path, dirname);
1128
1129 fattr = GetFileAttributes(dirp->path);
1130 if (fattr == 0xffffffff) {
1131 free(dirp->path);
1132 free(dirp);
1133 errno = ENOENT;
1134 return 0;
1135 } else if ((fattr & FILE_ATTRIBUTE_DIRECTORY) == 0) {
1136 free(dirp->path);
1137 free(dirp);
1138 errno = ENOTDIR;
1139 return 0;
1140 }
1141
1142 // Append "*.*", or possibly "\\*.*", to path
1143 if (dirp->path[1] == ':' &&
1144 (dirp->path[2] == '\0' ||
1145 (dirp->path[2] == '\\' && dirp->path[3] == '\0'))) {
1146 // No '\\' needed for cases like "Z:" or "Z:\"
1147 strcat(dirp->path, "*.*");
1148 } else {
1149 strcat(dirp->path, "\\*.*");
1150 }
1151
1152 dirp->handle = FindFirstFile(dirp->path, &dirp->find_data);
1153 if (dirp->handle == INVALID_HANDLE_VALUE) {
1154 if (GetLastError() != ERROR_FILE_NOT_FOUND) {
1155 free(dirp->path);
1156 free(dirp);
1157 errno = EACCES;
1158 return 0;
1159 }
1160 }
1161 return dirp;
1162 }
1163
1164 // parameter dbuf unused on Windows
1165 struct dirent * os::readdir(DIR *dirp, dirent *dbuf) {
1166 assert(dirp != NULL, "just checking"); // hotspot change
1167 if (dirp->handle == INVALID_HANDLE_VALUE) {
1168 return 0;
1169 }
1170
1171 strcpy(dirp->dirent.d_name, dirp->find_data.cFileName);
1172
1173 if (!FindNextFile(dirp->handle, &dirp->find_data)) {
1174 if (GetLastError() == ERROR_INVALID_HANDLE) {
1175 errno = EBADF;
1176 return 0;
1177 }
1178 FindClose(dirp->handle);
1179 dirp->handle = INVALID_HANDLE_VALUE;
1180 }
1181
1182 return &dirp->dirent;
1183 }
1184
1185 int os::closedir(DIR *dirp) {
1186 assert(dirp != NULL, "just checking"); // hotspot change
1187 if (dirp->handle != INVALID_HANDLE_VALUE) {
1188 if (!FindClose(dirp->handle)) {
1189 errno = EBADF;
1190 return -1;
1191 }
1192 dirp->handle = INVALID_HANDLE_VALUE;
1193 }
1194 free(dirp->path);
1195 free(dirp);
1196 return 0;
1197 }
1198
1199 // This must be hard coded because it's the system's temporary
1200 // directory not the java application's temp directory, ala java.io.tmpdir.
1201 const char* os::get_temp_directory() {
1202 static char path_buf[MAX_PATH];
1203 if (GetTempPath(MAX_PATH, path_buf) > 0) {
1204 return path_buf;
1205 } else {
1206 path_buf[0] = '\0';
1207 return path_buf;
1208 }
1209 }
1210
1211 static bool file_exists(const char* filename) {
1212 if (filename == NULL || strlen(filename) == 0) {
1213 return false;
1214 }
1215 return GetFileAttributes(filename) != INVALID_FILE_ATTRIBUTES;
1216 }
1217
1218 bool os::dll_build_name(char *buffer, size_t buflen,
1219 const char* pname, const char* fname) {
1220 bool retval = false;
1221 const size_t pnamelen = pname ? strlen(pname) : 0;
1222 const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
1223
1224 // Return error on buffer overflow.
1225 if (pnamelen + strlen(fname) + 10 > buflen) {
1226 return retval;
1227 }
1228
1229 if (pnamelen == 0) {
1230 jio_snprintf(buffer, buflen, "%s.dll", fname);
1231 retval = true;
1232 } else if (c == ':' || c == '\\') {
1233 jio_snprintf(buffer, buflen, "%s%s.dll", pname, fname);
1234 retval = true;
1235 } else if (strchr(pname, *os::path_separator()) != NULL) {
1236 int n;
1237 char** pelements = split_path(pname, &n);
1238 if (pelements == NULL) {
1239 return false;
1240 }
1241 for (int i = 0; i < n; i++) {
1242 char* path = pelements[i];
1243 // Really shouldn't be NULL, but check can't hurt
1244 size_t plen = (path == NULL) ? 0 : strlen(path);
1245 if (plen == 0) {
1246 continue; // skip the empty path values
1247 }
1248 const char lastchar = path[plen - 1];
1249 if (lastchar == ':' || lastchar == '\\') {
1250 jio_snprintf(buffer, buflen, "%s%s.dll", path, fname);
1251 } else {
1252 jio_snprintf(buffer, buflen, "%s\\%s.dll", path, fname);
1253 }
1254 if (file_exists(buffer)) {
1255 retval = true;
1256 break;
1257 }
1258 }
1259 // release the storage
1260 for (int i = 0; i < n; i++) {
1261 if (pelements[i] != NULL) {
1262 FREE_C_HEAP_ARRAY(char, pelements[i]);
1263 }
1264 }
1265 if (pelements != NULL) {
1266 FREE_C_HEAP_ARRAY(char*, pelements);
1267 }
1268 } else {
1269 jio_snprintf(buffer, buflen, "%s\\%s.dll", pname, fname);
1270 retval = true;
1271 }
1272 return retval;
1273 }
1274
1275 // Needs to be in os specific directory because windows requires another
1276 // header file <direct.h>
1277 const char* os::get_current_directory(char *buf, size_t buflen) {
1278 int n = static_cast<int>(buflen);
1279 if (buflen > INT_MAX) n = INT_MAX;
1280 return _getcwd(buf, n);
1281 }
1282
1283 //-----------------------------------------------------------
1284 // Helper functions for fatal error handler
1285 #ifdef _WIN64
1286 // Helper routine which returns true if address in
1287 // within the NTDLL address space.
1288 //
1289 static bool _addr_in_ntdll(address addr) {
1290 HMODULE hmod;
1291 MODULEINFO minfo;
1292
1293 hmod = GetModuleHandle("NTDLL.DLL");
1294 if (hmod == NULL) return false;
1295 if (!GetModuleInformation(GetCurrentProcess(), hmod,
1296 &minfo, sizeof(MODULEINFO))) {
1297 return false;
1298 }
1299
1300 if ((addr >= minfo.lpBaseOfDll) &&
1301 (addr < (address)((uintptr_t)minfo.lpBaseOfDll + (uintptr_t)minfo.SizeOfImage))) {
1302 return true;
1303 } else {
1304 return false;
1305 }
1306 }
1307 #endif
1308
1309 struct _modinfo {
1310 address addr;
1311 char* full_path; // point to a char buffer
1312 int buflen; // size of the buffer
1313 address base_addr;
1314 };
1315
1316 static int _locate_module_by_addr(const char * mod_fname, address base_addr,
1317 address top_address, void * param) {
1318 struct _modinfo *pmod = (struct _modinfo *)param;
1319 if (!pmod) return -1;
1320
1321 if (base_addr <= pmod->addr &&
1322 top_address > pmod->addr) {
1323 // if a buffer is provided, copy path name to the buffer
1324 if (pmod->full_path) {
1325 jio_snprintf(pmod->full_path, pmod->buflen, "%s", mod_fname);
1326 }
1327 pmod->base_addr = base_addr;
1328 return 1;
1329 }
1330 return 0;
1331 }
1332
1333 bool os::dll_address_to_library_name(address addr, char* buf,
1334 int buflen, int* offset) {
1335 // buf is not optional, but offset is optional
1336 assert(buf != NULL, "sanity check");
1337
1338 // NOTE: the reason we don't use SymGetModuleInfo() is it doesn't always
1339 // return the full path to the DLL file, sometimes it returns path
1340 // to the corresponding PDB file (debug info); sometimes it only
1341 // returns partial path, which makes life painful.
1342
1343 struct _modinfo mi;
1344 mi.addr = addr;
1345 mi.full_path = buf;
1346 mi.buflen = buflen;
1347 if (get_loaded_modules_info(_locate_module_by_addr, (void *)&mi)) {
1348 // buf already contains path name
1349 if (offset) *offset = addr - mi.base_addr;
1350 return true;
1351 }
1352
1353 buf[0] = '\0';
1354 if (offset) *offset = -1;
1355 return false;
1356 }
1357
1358 bool os::dll_address_to_function_name(address addr, char *buf,
1359 int buflen, int *offset,
1360 bool demangle) {
1361 // buf is not optional, but offset is optional
1362 assert(buf != NULL, "sanity check");
1363
1364 if (Decoder::decode(addr, buf, buflen, offset, demangle)) {
1365 return true;
1366 }
1367 if (offset != NULL) *offset = -1;
1368 buf[0] = '\0';
1369 return false;
1370 }
1371
1372 // save the start and end address of jvm.dll into param[0] and param[1]
1373 static int _locate_jvm_dll(const char* mod_fname, address base_addr,
1374 address top_address, void * param) {
1375 if (!param) return -1;
1376
1377 if (base_addr <= (address)_locate_jvm_dll &&
1378 top_address > (address)_locate_jvm_dll) {
1379 ((address*)param)[0] = base_addr;
1380 ((address*)param)[1] = top_address;
1381 return 1;
1382 }
1383 return 0;
1384 }
1385
1386 address vm_lib_location[2]; // start and end address of jvm.dll
1387
1388 // check if addr is inside jvm.dll
1389 bool os::address_is_in_vm(address addr) {
1390 if (!vm_lib_location[0] || !vm_lib_location[1]) {
1391 if (!get_loaded_modules_info(_locate_jvm_dll, (void *)vm_lib_location)) {
1392 assert(false, "Can't find jvm module.");
1393 return false;
1394 }
1395 }
1396
1397 return (vm_lib_location[0] <= addr) && (addr < vm_lib_location[1]);
1398 }
1399
1400 // print module info; param is outputStream*
1401 static int _print_module(const char* fname, address base_address,
1402 address top_address, void* param) {
1403 if (!param) return -1;
1404
1405 outputStream* st = (outputStream*)param;
1406
1407 st->print(PTR_FORMAT " - " PTR_FORMAT " \t%s\n", base_address, top_address, fname);
1408 return 0;
1409 }
1410
1411 // Loads .dll/.so and
1412 // in case of error it checks if .dll/.so was built for the
1413 // same architecture as Hotspot is running on
1414 void * os::dll_load(const char *name, char *ebuf, int ebuflen) {
1415 void * result = LoadLibrary(name);
1416 if (result != NULL) {
1417 return result;
1418 }
1419
1420 DWORD errcode = GetLastError();
1421 if (errcode == ERROR_MOD_NOT_FOUND) {
1422 strncpy(ebuf, "Can't find dependent libraries", ebuflen - 1);
1423 ebuf[ebuflen - 1] = '\0';
1424 return NULL;
1425 }
1426
1427 // Parsing dll below
1428 // If we can read dll-info and find that dll was built
1429 // for an architecture other than Hotspot is running in
1430 // - then print to buffer "DLL was built for a different architecture"
1431 // else call os::lasterror to obtain system error message
1432
1433 // Read system error message into ebuf
1434 // It may or may not be overwritten below (in the for loop and just above)
1435 lasterror(ebuf, (size_t) ebuflen);
1436 ebuf[ebuflen - 1] = '\0';
1437 int fd = ::open(name, O_RDONLY | O_BINARY, 0);
1438 if (fd < 0) {
1439 return NULL;
1440 }
1441
1442 uint32_t signature_offset;
1443 uint16_t lib_arch = 0;
1444 bool failed_to_get_lib_arch =
1445 ( // Go to position 3c in the dll
1446 (os::seek_to_file_offset(fd, IMAGE_FILE_PTR_TO_SIGNATURE) < 0)
1447 ||
1448 // Read location of signature
1449 (sizeof(signature_offset) !=
1450 (os::read(fd, (void*)&signature_offset, sizeof(signature_offset))))
1451 ||
1452 // Go to COFF File Header in dll
1453 // that is located after "signature" (4 bytes long)
1454 (os::seek_to_file_offset(fd,
1455 signature_offset + IMAGE_FILE_SIGNATURE_LENGTH) < 0)
1456 ||
1457 // Read field that contains code of architecture
1458 // that dll was built for
1459 (sizeof(lib_arch) != (os::read(fd, (void*)&lib_arch, sizeof(lib_arch))))
1460 );
1461
1462 ::close(fd);
1463 if (failed_to_get_lib_arch) {
1464 // file i/o error - report os::lasterror(...) msg
1465 return NULL;
1466 }
1467
1468 typedef struct {
1469 uint16_t arch_code;
1470 char* arch_name;
1471 } arch_t;
1472
1473 static const arch_t arch_array[] = {
1474 {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"},
1475 {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"},
1476 {IMAGE_FILE_MACHINE_IA64, (char*)"IA 64"}
1477 };
1478 #if (defined _M_IA64)
1479 static const uint16_t running_arch = IMAGE_FILE_MACHINE_IA64;
1480 #elif (defined _M_AMD64)
1481 static const uint16_t running_arch = IMAGE_FILE_MACHINE_AMD64;
1482 #elif (defined _M_IX86)
1483 static const uint16_t running_arch = IMAGE_FILE_MACHINE_I386;
1484 #else
1485 #error Method os::dll_load requires that one of following \
1486 is defined :_M_IA64,_M_AMD64 or _M_IX86
1487 #endif
1488
1489
1490 // Obtain a string for printf operation
1491 // lib_arch_str shall contain string what platform this .dll was built for
1492 // running_arch_str shall string contain what platform Hotspot was built for
1493 char *running_arch_str = NULL, *lib_arch_str = NULL;
1494 for (unsigned int i = 0; i < ARRAY_SIZE(arch_array); i++) {
1495 if (lib_arch == arch_array[i].arch_code) {
1496 lib_arch_str = arch_array[i].arch_name;
1497 }
1498 if (running_arch == arch_array[i].arch_code) {
1499 running_arch_str = arch_array[i].arch_name;
1500 }
1501 }
1502
1503 assert(running_arch_str,
1504 "Didn't find running architecture code in arch_array");
1505
1506 // If the architecture is right
1507 // but some other error took place - report os::lasterror(...) msg
1508 if (lib_arch == running_arch) {
1509 return NULL;
1510 }
1511
1512 if (lib_arch_str != NULL) {
1513 ::_snprintf(ebuf, ebuflen - 1,
1514 "Can't load %s-bit .dll on a %s-bit platform",
1515 lib_arch_str, running_arch_str);
1516 } else {
1517 // don't know what architecture this dll was build for
1518 ::_snprintf(ebuf, ebuflen - 1,
1519 "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
1520 lib_arch, running_arch_str);
1521 }
1522
1523 return NULL;
1524 }
1525
1526 void os::print_dll_info(outputStream *st) {
1527 st->print_cr("Dynamic libraries:");
1528 get_loaded_modules_info(_print_module, (void *)st);
1529 }
1530
1531 int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
1532 HANDLE hProcess;
1533
1534 # define MAX_NUM_MODULES 128
1535 HMODULE modules[MAX_NUM_MODULES];
1536 static char filename[MAX_PATH];
1537 int result = 0;
1538
1539 int pid = os::current_process_id();
1540 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1541 FALSE, pid);
1542 if (hProcess == NULL) return 0;
1543
1544 DWORD size_needed;
1545 if (!EnumProcessModules(hProcess, modules, sizeof(modules), &size_needed)) {
1546 CloseHandle(hProcess);
1547 return 0;
1548 }
1549
1550 // number of modules that are currently loaded
1551 int num_modules = size_needed / sizeof(HMODULE);
1552
1553 for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1554 // Get Full pathname:
1555 if (!GetModuleFileNameEx(hProcess, modules[i], filename, sizeof(filename))) {
1556 filename[0] = '\0';
1557 }
1558
1559 MODULEINFO modinfo;
1560 if (!GetModuleInformation(hProcess, modules[i], &modinfo, sizeof(modinfo))) {
1561 modinfo.lpBaseOfDll = NULL;
1562 modinfo.SizeOfImage = 0;
1563 }
1564
1565 // Invoke callback function
1566 result = callback(filename, (address)modinfo.lpBaseOfDll,
1567 (address)((u8)modinfo.lpBaseOfDll + (u8)modinfo.SizeOfImage), param);
1568 if (result) break;
1569 }
1570
1571 CloseHandle(hProcess);
1572 return result;
1573 }
1574
1575 bool os::get_host_name(char* buf, size_t buflen) {
1576 DWORD size = (DWORD)buflen;
1577 return (GetComputerNameEx(ComputerNameDnsHostname, buf, &size) == TRUE);
1578 }
1579
1580 void os::get_summary_os_info(char* buf, size_t buflen) {
1581 stringStream sst(buf, buflen);
1582 os::win32::print_windows_version(&sst);
1583 // chop off newline character
1584 char* nl = strchr(buf, '\n');
1585 if (nl != NULL) *nl = '\0';
1586 }
1587
1588 int os::log_vsnprintf(char* buf, size_t len, const char* fmt, va_list args) {
1589 int ret = vsnprintf(buf, len, fmt, args);
1590 // Get the correct buffer size if buf is too small
1591 if (ret < 0) {
1592 return _vscprintf(fmt, args);
1593 }
1594 return ret;
1595 }
1596
1597 static inline time_t get_mtime(const char* filename) {
1598 struct stat st;
1599 int ret = os::stat(filename, &st);
1600 assert(ret == 0, "failed to stat() file '%s': %s", filename, strerror(errno));
1601 return st.st_mtime;
1602 }
1603
1604 int os::compare_file_modified_times(const char* file1, const char* file2) {
1605 time_t t1 = get_mtime(file1);
1606 time_t t2 = get_mtime(file2);
1607 return t1 - t2;
1608 }
1609
1610 void os::print_os_info_brief(outputStream* st) {
1611 os::print_os_info(st);
1612 }
1613
1614 void os::print_os_info(outputStream* st) {
1615 #ifdef ASSERT
1616 char buffer[1024];
1617 st->print("HostName: ");
1618 if (get_host_name(buffer, sizeof(buffer))) {
1619 st->print("%s ", buffer);
1620 } else {
1621 st->print("N/A ");
1622 }
1623 #endif
1624 st->print("OS:");
1625 os::win32::print_windows_version(st);
1626 }
1627
1628 void os::win32::print_windows_version(outputStream* st) {
1629 OSVERSIONINFOEX osvi;
1630 VS_FIXEDFILEINFO *file_info;
1631 TCHAR kernel32_path[MAX_PATH];
1632 UINT len, ret;
1633
1634 // Use the GetVersionEx information to see if we're on a server or
1635 // workstation edition of Windows. Starting with Windows 8.1 we can't
1636 // trust the OS version information returned by this API.
1637 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1638 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1639 if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1640 st->print_cr("Call to GetVersionEx failed");
1641 return;
1642 }
1643 bool is_workstation = (osvi.wProductType == VER_NT_WORKSTATION);
1644
1645 // Get the full path to \Windows\System32\kernel32.dll and use that for
1646 // determining what version of Windows we're running on.
1647 len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1;
1648 ret = GetSystemDirectory(kernel32_path, len);
1649 if (ret == 0 || ret > len) {
1650 st->print_cr("Call to GetSystemDirectory failed");
1651 return;
1652 }
1653 strncat(kernel32_path, "\\kernel32.dll", MAX_PATH - ret);
1654
1655 DWORD version_size = GetFileVersionInfoSize(kernel32_path, NULL);
1656 if (version_size == 0) {
1657 st->print_cr("Call to GetFileVersionInfoSize failed");
1658 return;
1659 }
1660
1661 LPTSTR version_info = (LPTSTR)os::malloc(version_size, mtInternal);
1662 if (version_info == NULL) {
1663 st->print_cr("Failed to allocate version_info");
1664 return;
1665 }
1666
1667 if (!GetFileVersionInfo(kernel32_path, NULL, version_size, version_info)) {
1668 os::free(version_info);
1669 st->print_cr("Call to GetFileVersionInfo failed");
1670 return;
1671 }
1672
1673 if (!VerQueryValue(version_info, TEXT("\\"), (LPVOID*)&file_info, &len)) {
1674 os::free(version_info);
1675 st->print_cr("Call to VerQueryValue failed");
1676 return;
1677 }
1678
1679 int major_version = HIWORD(file_info->dwProductVersionMS);
1680 int minor_version = LOWORD(file_info->dwProductVersionMS);
1681 int build_number = HIWORD(file_info->dwProductVersionLS);
1682 int build_minor = LOWORD(file_info->dwProductVersionLS);
1683 int os_vers = major_version * 1000 + minor_version;
1684 os::free(version_info);
1685
1686 st->print(" Windows ");
1687 switch (os_vers) {
1688
1689 case 6000:
1690 if (is_workstation) {
1691 st->print("Vista");
1692 } else {
1693 st->print("Server 2008");
1694 }
1695 break;
1696
1697 case 6001:
1698 if (is_workstation) {
1699 st->print("7");
1700 } else {
1701 st->print("Server 2008 R2");
1702 }
1703 break;
1704
1705 case 6002:
1706 if (is_workstation) {
1707 st->print("8");
1708 } else {
1709 st->print("Server 2012");
1710 }
1711 break;
1712
1713 case 6003:
1714 if (is_workstation) {
1715 st->print("8.1");
1716 } else {
1717 st->print("Server 2012 R2");
1718 }
1719 break;
1720
1721 case 10000:
1722 if (is_workstation) {
1723 st->print("10");
1724 } else {
1725 st->print("Server 2016");
1726 }
1727 break;
1728
1729 default:
1730 // Unrecognized windows, print out its major and minor versions
1731 st->print("%d.%d", major_version, minor_version);
1732 break;
1733 }
1734
1735 // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1736 // find out whether we are running on 64 bit processor or not
1737 SYSTEM_INFO si;
1738 ZeroMemory(&si, sizeof(SYSTEM_INFO));
1739 GetNativeSystemInfo(&si);
1740 if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
1741 st->print(" , 64 bit");
1742 }
1743
1744 st->print(" Build %d", build_number);
1745 st->print(" (%d.%d.%d.%d)", major_version, minor_version, build_number, build_minor);
1746 st->cr();
1747 }
1748
1749 void os::pd_print_cpu_info(outputStream* st, char* buf, size_t buflen) {
1750 // Nothing to do for now.
1751 }
1752
1753 void os::get_summary_cpu_info(char* buf, size_t buflen) {
1754 HKEY key;
1755 DWORD status = RegOpenKey(HKEY_LOCAL_MACHINE,
1756 "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0", &key);
1757 if (status == ERROR_SUCCESS) {
1758 DWORD size = (DWORD)buflen;
1759 status = RegQueryValueEx(key, "ProcessorNameString", NULL, NULL, (byte*)buf, &size);
1760 if (status != ERROR_SUCCESS) {
1761 strncpy(buf, "## __CPU__", buflen);
1762 }
1763 RegCloseKey(key);
1764 } else {
1765 // Put generic cpu info to return
1766 strncpy(buf, "## __CPU__", buflen);
1767 }
1768 }
1769
1770 void os::print_memory_info(outputStream* st) {
1771 st->print("Memory:");
1772 st->print(" %dk page", os::vm_page_size()>>10);
1773
1774 // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1775 // value if total memory is larger than 4GB
1776 MEMORYSTATUSEX ms;
1777 ms.dwLength = sizeof(ms);
1778 GlobalMemoryStatusEx(&ms);
1779
1780 st->print(", physical %uk", os::physical_memory() >> 10);
1781 st->print("(%uk free)", os::available_memory() >> 10);
1782
1783 st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1784 st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1785 st->cr();
1786 }
1787
1788 void os::print_siginfo(outputStream *st, const void* siginfo) {
1789 const EXCEPTION_RECORD* const er = (EXCEPTION_RECORD*)siginfo;
1790 st->print("siginfo:");
1791
1792 char tmp[64];
1793 if (os::exception_name(er->ExceptionCode, tmp, sizeof(tmp)) == NULL) {
1794 strcpy(tmp, "EXCEPTION_??");
1795 }
1796 st->print(" %s (0x%x)", tmp, er->ExceptionCode);
1797
1798 if ((er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
1799 er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR) &&
1800 er->NumberParameters >= 2) {
1801 switch (er->ExceptionInformation[0]) {
1802 case 0: st->print(", reading address"); break;
1803 case 1: st->print(", writing address"); break;
1804 case 8: st->print(", data execution prevention violation at address"); break;
1805 default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1806 er->ExceptionInformation[0]);
1807 }
1808 st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1809 } else {
1810 int num = er->NumberParameters;
1811 if (num > 0) {
1812 st->print(", ExceptionInformation=");
1813 for (int i = 0; i < num; i++) {
1814 st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1815 }
1816 }
1817 }
1818 st->cr();
1819 }
1820
1821 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1822 // do nothing
1823 }
1824
1825 static char saved_jvm_path[MAX_PATH] = {0};
1826
1827 // Find the full path to the current module, jvm.dll
1828 void os::jvm_path(char *buf, jint buflen) {
1829 // Error checking.
1830 if (buflen < MAX_PATH) {
1831 assert(false, "must use a large-enough buffer");
1832 buf[0] = '\0';
1833 return;
1834 }
1835 // Lazy resolve the path to current module.
1836 if (saved_jvm_path[0] != 0) {
1837 strcpy(buf, saved_jvm_path);
1838 return;
1839 }
1840
1841 buf[0] = '\0';
1842 if (Arguments::sun_java_launcher_is_altjvm()) {
1843 // Support for the java launcher's '-XXaltjvm=<path>' option. Check
1844 // for a JAVA_HOME environment variable and fix up the path so it
1845 // looks like jvm.dll is installed there (append a fake suffix
1846 // hotspot/jvm.dll).
1847 char* java_home_var = ::getenv("JAVA_HOME");
1848 if (java_home_var != NULL && java_home_var[0] != 0 &&
1849 strlen(java_home_var) < (size_t)buflen) {
1850 strncpy(buf, java_home_var, buflen);
1851
1852 // determine if this is a legacy image or modules image
1853 // modules image doesn't have "jre" subdirectory
1854 size_t len = strlen(buf);
1855 char* jrebin_p = buf + len;
1856 jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1857 if (0 != _access(buf, 0)) {
1858 jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1859 }
1860 len = strlen(buf);
1861 jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1862 }
1863 }
1864
1865 if (buf[0] == '\0') {
1866 GetModuleFileName(vm_lib_handle, buf, buflen);
1867 }
1868 strncpy(saved_jvm_path, buf, MAX_PATH);
1869 saved_jvm_path[MAX_PATH - 1] = '\0';
1870 }
1871
1872
1873 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1874 #ifndef _WIN64
1875 st->print("_");
1876 #endif
1877 }
1878
1879
1880 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1881 #ifndef _WIN64
1882 st->print("@%d", args_size * sizeof(int));
1883 #endif
1884 }
1885
1886 // This method is a copy of JDK's sysGetLastErrorString
1887 // from src/windows/hpi/src/system_md.c
1888
1889 size_t os::lasterror(char* buf, size_t len) {
1890 DWORD errval;
1891
1892 if ((errval = GetLastError()) != 0) {
1893 // DOS error
1894 size_t n = (size_t)FormatMessage(
1895 FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1896 NULL,
1897 errval,
1898 0,
1899 buf,
1900 (DWORD)len,
1901 NULL);
1902 if (n > 3) {
1903 // Drop final '.', CR, LF
1904 if (buf[n - 1] == '\n') n--;
1905 if (buf[n - 1] == '\r') n--;
1906 if (buf[n - 1] == '.') n--;
1907 buf[n] = '\0';
1908 }
1909 return n;
1910 }
1911
1912 if (errno != 0) {
1913 // C runtime error that has no corresponding DOS error code
1914 const char* s = os::strerror(errno);
1915 size_t n = strlen(s);
1916 if (n >= len) n = len - 1;
1917 strncpy(buf, s, n);
1918 buf[n] = '\0';
1919 return n;
1920 }
1921
1922 return 0;
1923 }
1924
1925 int os::get_last_error() {
1926 DWORD error = GetLastError();
1927 if (error == 0) {
1928 error = errno;
1929 }
1930 return (int)error;
1931 }
1932
1933 WindowsSemaphore::WindowsSemaphore(uint value) {
1934 _semaphore = ::CreateSemaphore(NULL, value, LONG_MAX, NULL);
1935
1936 guarantee(_semaphore != NULL, "CreateSemaphore failed with error code: %lu", GetLastError());
1937 }
1938
1939 WindowsSemaphore::~WindowsSemaphore() {
1940 ::CloseHandle(_semaphore);
1941 }
1942
1943 void WindowsSemaphore::signal(uint count) {
1944 if (count > 0) {
1945 BOOL ret = ::ReleaseSemaphore(_semaphore, count, NULL);
1946
1947 assert(ret != 0, "ReleaseSemaphore failed with error code: %lu", GetLastError());
1948 }
1949 }
1950
1951 void WindowsSemaphore::wait() {
1952 DWORD ret = ::WaitForSingleObject(_semaphore, INFINITE);
1953 assert(ret != WAIT_FAILED, "WaitForSingleObject failed with error code: %lu", GetLastError());
1954 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject failed with return value: %lu", ret);
1955 }
1956
1957 // sun.misc.Signal
1958 // NOTE that this is a workaround for an apparent kernel bug where if
1959 // a signal handler for SIGBREAK is installed then that signal handler
1960 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1961 // See bug 4416763.
1962 static void (*sigbreakHandler)(int) = NULL;
1963
1964 static void UserHandler(int sig, void *siginfo, void *context) {
1965 os::signal_notify(sig);
1966 // We need to reinstate the signal handler each time...
1967 os::signal(sig, (void*)UserHandler);
1968 }
1969
1970 void* os::user_handler() {
1971 return (void*) UserHandler;
1972 }
1973
1974 void* os::signal(int signal_number, void* handler) {
1975 if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1976 void (*oldHandler)(int) = sigbreakHandler;
1977 sigbreakHandler = (void (*)(int)) handler;
1978 return (void*) oldHandler;
1979 } else {
1980 return (void*)::signal(signal_number, (void (*)(int))handler);
1981 }
1982 }
1983
1984 void os::signal_raise(int signal_number) {
1985 raise(signal_number);
1986 }
1987
1988 // The Win32 C runtime library maps all console control events other than ^C
1989 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1990 // logoff, and shutdown events. We therefore install our own console handler
1991 // that raises SIGTERM for the latter cases.
1992 //
1993 static BOOL WINAPI consoleHandler(DWORD event) {
1994 switch (event) {
1995 case CTRL_C_EVENT:
1996 if (is_error_reported()) {
1997 // Ctrl-C is pressed during error reporting, likely because the error
1998 // handler fails to abort. Let VM die immediately.
1999 os::die();
2000 }
2001
2002 os::signal_raise(SIGINT);
2003 return TRUE;
2004 break;
2005 case CTRL_BREAK_EVENT:
2006 if (sigbreakHandler != NULL) {
2007 (*sigbreakHandler)(SIGBREAK);
2008 }
2009 return TRUE;
2010 break;
2011 case CTRL_LOGOFF_EVENT: {
2012 // Don't terminate JVM if it is running in a non-interactive session,
2013 // such as a service process.
2014 USEROBJECTFLAGS flags;
2015 HANDLE handle = GetProcessWindowStation();
2016 if (handle != NULL &&
2017 GetUserObjectInformation(handle, UOI_FLAGS, &flags,
2018 sizeof(USEROBJECTFLAGS), NULL)) {
2019 // If it is a non-interactive session, let next handler to deal
2020 // with it.
2021 if ((flags.dwFlags & WSF_VISIBLE) == 0) {
2022 return FALSE;
2023 }
2024 }
2025 }
2026 case CTRL_CLOSE_EVENT:
2027 case CTRL_SHUTDOWN_EVENT:
2028 os::signal_raise(SIGTERM);
2029 return TRUE;
2030 break;
2031 default:
2032 break;
2033 }
2034 return FALSE;
2035 }
2036
2037 // The following code is moved from os.cpp for making this
2038 // code platform specific, which it is by its very nature.
2039
2040 // Return maximum OS signal used + 1 for internal use only
2041 // Used as exit signal for signal_thread
2042 int os::sigexitnum_pd() {
2043 return NSIG;
2044 }
2045
2046 // a counter for each possible signal value, including signal_thread exit signal
2047 static volatile jint pending_signals[NSIG+1] = { 0 };
2048 static HANDLE sig_sem = NULL;
2049
2050 void os::signal_init_pd() {
2051 // Initialize signal structures
2052 memset((void*)pending_signals, 0, sizeof(pending_signals));
2053
2054 sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
2055
2056 // Programs embedding the VM do not want it to attempt to receive
2057 // events like CTRL_LOGOFF_EVENT, which are used to implement the
2058 // shutdown hooks mechanism introduced in 1.3. For example, when
2059 // the VM is run as part of a Windows NT service (i.e., a servlet
2060 // engine in a web server), the correct behavior is for any console
2061 // control handler to return FALSE, not TRUE, because the OS's
2062 // "final" handler for such events allows the process to continue if
2063 // it is a service (while terminating it if it is not a service).
2064 // To make this behavior uniform and the mechanism simpler, we
2065 // completely disable the VM's usage of these console events if -Xrs
2066 // (=ReduceSignalUsage) is specified. This means, for example, that
2067 // the CTRL-BREAK thread dump mechanism is also disabled in this
2068 // case. See bugs 4323062, 4345157, and related bugs.
2069
2070 if (!ReduceSignalUsage) {
2071 // Add a CTRL-C handler
2072 SetConsoleCtrlHandler(consoleHandler, TRUE);
2073 }
2074 }
2075
2076 void os::signal_notify(int signal_number) {
2077 BOOL ret;
2078 if (sig_sem != NULL) {
2079 Atomic::inc(&pending_signals[signal_number]);
2080 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2081 assert(ret != 0, "ReleaseSemaphore() failed");
2082 }
2083 }
2084
2085 static int check_pending_signals(bool wait_for_signal) {
2086 DWORD ret;
2087 while (true) {
2088 for (int i = 0; i < NSIG + 1; i++) {
2089 jint n = pending_signals[i];
2090 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2091 return i;
2092 }
2093 }
2094 if (!wait_for_signal) {
2095 return -1;
2096 }
2097
2098 JavaThread *thread = JavaThread::current();
2099
2100 ThreadBlockInVM tbivm(thread);
2101
2102 bool threadIsSuspended;
2103 do {
2104 thread->set_suspend_equivalent();
2105 // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2106 ret = ::WaitForSingleObject(sig_sem, INFINITE);
2107 assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
2108
2109 // were we externally suspended while we were waiting?
2110 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2111 if (threadIsSuspended) {
2112 // The semaphore has been incremented, but while we were waiting
2113 // another thread suspended us. We don't want to continue running
2114 // while suspended because that would surprise the thread that
2115 // suspended us.
2116 ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2117 assert(ret != 0, "ReleaseSemaphore() failed");
2118
2119 thread->java_suspend_self();
2120 }
2121 } while (threadIsSuspended);
2122 }
2123 }
2124
2125 int os::signal_lookup() {
2126 return check_pending_signals(false);
2127 }
2128
2129 int os::signal_wait() {
2130 return check_pending_signals(true);
2131 }
2132
2133 // Implicit OS exception handling
2134
2135 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo,
2136 address handler) {
2137 JavaThread* thread = (JavaThread*) Thread::current_or_null();
2138 // Save pc in thread
2139 #ifdef _M_IA64
2140 // Do not blow up if no thread info available.
2141 if (thread) {
2142 // Saving PRECISE pc (with slot information) in thread.
2143 uint64_t precise_pc = (uint64_t) exceptionInfo->ExceptionRecord->ExceptionAddress;
2144 // Convert precise PC into "Unix" format
2145 precise_pc = (precise_pc & 0xFFFFFFFFFFFFFFF0) | ((precise_pc & 0xF) >> 2);
2146 thread->set_saved_exception_pc((address)precise_pc);
2147 }
2148 // Set pc to handler
2149 exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
2150 // Clear out psr.ri (= Restart Instruction) in order to continue
2151 // at the beginning of the target bundle.
2152 exceptionInfo->ContextRecord->StIPSR &= 0xFFFFF9FFFFFFFFFF;
2153 assert(((DWORD64)handler & 0xF) == 0, "Target address must point to the beginning of a bundle!");
2154 #else
2155 #ifdef _M_AMD64
2156 // Do not blow up if no thread info available.
2157 if (thread) {
2158 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Rip);
2159 }
2160 // Set pc to handler
2161 exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
2162 #else
2163 // Do not blow up if no thread info available.
2164 if (thread) {
2165 thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Eip);
2166 }
2167 // Set pc to handler
2168 exceptionInfo->ContextRecord->Eip = (DWORD)(DWORD_PTR)handler;
2169 #endif
2170 #endif
2171
2172 // Continue the execution
2173 return EXCEPTION_CONTINUE_EXECUTION;
2174 }
2175
2176
2177 // Used for PostMortemDump
2178 extern "C" void safepoints();
2179 extern "C" void find(int x);
2180 extern "C" void events();
2181
2182 // According to Windows API documentation, an illegal instruction sequence should generate
2183 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2184 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2185 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2186
2187 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2188
2189 // From "Execution Protection in the Windows Operating System" draft 0.35
2190 // Once a system header becomes available, the "real" define should be
2191 // included or copied here.
2192 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2193
2194 // Handle NAT Bit consumption on IA64.
2195 #ifdef _M_IA64
2196 #define EXCEPTION_REG_NAT_CONSUMPTION STATUS_REG_NAT_CONSUMPTION
2197 #endif
2198
2199 // Windows Vista/2008 heap corruption check
2200 #define EXCEPTION_HEAP_CORRUPTION 0xC0000374
2201
2202 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2203 // C++ compiler contain this error code. Because this is a compiler-generated
2204 // error, the code is not listed in the Win32 API header files.
2205 // The code is actually a cryptic mnemonic device, with the initial "E"
2206 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2207 // ASCII values of "msc".
2208
2209 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION 0xE06D7363
2210
2211 #define def_excpt(val) { #val, (val) }
2212
2213 static const struct { char* name; uint number; } exceptlabels[] = {
2214 def_excpt(EXCEPTION_ACCESS_VIOLATION),
2215 def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2216 def_excpt(EXCEPTION_BREAKPOINT),
2217 def_excpt(EXCEPTION_SINGLE_STEP),
2218 def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2219 def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2220 def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2221 def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2222 def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2223 def_excpt(EXCEPTION_FLT_OVERFLOW),
2224 def_excpt(EXCEPTION_FLT_STACK_CHECK),
2225 def_excpt(EXCEPTION_FLT_UNDERFLOW),
2226 def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2227 def_excpt(EXCEPTION_INT_OVERFLOW),
2228 def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2229 def_excpt(EXCEPTION_IN_PAGE_ERROR),
2230 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2231 def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2232 def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2233 def_excpt(EXCEPTION_STACK_OVERFLOW),
2234 def_excpt(EXCEPTION_INVALID_DISPOSITION),
2235 def_excpt(EXCEPTION_GUARD_PAGE),
2236 def_excpt(EXCEPTION_INVALID_HANDLE),
2237 def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2238 def_excpt(EXCEPTION_HEAP_CORRUPTION)
2239 #ifdef _M_IA64
2240 , def_excpt(EXCEPTION_REG_NAT_CONSUMPTION)
2241 #endif
2242 };
2243
2244 #undef def_excpt
2245
2246 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2247 uint code = static_cast<uint>(exception_code);
2248 for (uint i = 0; i < ARRAY_SIZE(exceptlabels); ++i) {
2249 if (exceptlabels[i].number == code) {
2250 jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2251 return buf;
2252 }
2253 }
2254
2255 return NULL;
2256 }
2257
2258 //-----------------------------------------------------------------------------
2259 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2260 // handle exception caused by idiv; should only happen for -MinInt/-1
2261 // (division by zero is handled explicitly)
2262 #ifdef _M_IA64
2263 assert(0, "Fix Handle_IDiv_Exception");
2264 #else
2265 #ifdef _M_AMD64
2266 PCONTEXT ctx = exceptionInfo->ContextRecord;
2267 address pc = (address)ctx->Rip;
2268 assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && pc[1] == 0xF7 || pc[0] == 0xF7, "not an idiv opcode");
2269 assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && (pc[2] & ~0x7) == 0xF8 || (pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2270 if (pc[0] == 0xF7) {
2271 // set correct result values and continue after idiv instruction
2272 ctx->Rip = (DWORD64)pc + 2; // idiv reg, reg is 2 bytes
2273 } else {
2274 ctx->Rip = (DWORD64)pc + 3; // REX idiv reg, reg is 3 bytes
2275 }
2276 // Do not set ctx->Rax as it already contains the correct value (either 32 or 64 bit, depending on the operation)
2277 // this is the case because the exception only happens for -MinValue/-1 and -MinValue is always in rax because of the
2278 // idiv opcode (0xF7).
2279 ctx->Rdx = (DWORD)0; // remainder
2280 // Continue the execution
2281 #else
2282 PCONTEXT ctx = exceptionInfo->ContextRecord;
2283 address pc = (address)ctx->Eip;
2284 assert(pc[0] == 0xF7, "not an idiv opcode");
2285 assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2286 assert(ctx->Eax == min_jint, "unexpected idiv exception");
2287 // set correct result values and continue after idiv instruction
2288 ctx->Eip = (DWORD)pc + 2; // idiv reg, reg is 2 bytes
2289 ctx->Eax = (DWORD)min_jint; // result
2290 ctx->Edx = (DWORD)0; // remainder
2291 // Continue the execution
2292 #endif
2293 #endif
2294 return EXCEPTION_CONTINUE_EXECUTION;
2295 }
2296
2297 //-----------------------------------------------------------------------------
2298 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2299 PCONTEXT ctx = exceptionInfo->ContextRecord;
2300 #ifndef _WIN64
2301 // handle exception caused by native method modifying control word
2302 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2303
2304 switch (exception_code) {
2305 case EXCEPTION_FLT_DENORMAL_OPERAND:
2306 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2307 case EXCEPTION_FLT_INEXACT_RESULT:
2308 case EXCEPTION_FLT_INVALID_OPERATION:
2309 case EXCEPTION_FLT_OVERFLOW:
2310 case EXCEPTION_FLT_STACK_CHECK:
2311 case EXCEPTION_FLT_UNDERFLOW:
2312 jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2313 if (fp_control_word != ctx->FloatSave.ControlWord) {
2314 // Restore FPCW and mask out FLT exceptions
2315 ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2316 // Mask out pending FLT exceptions
2317 ctx->FloatSave.StatusWord &= 0xffffff00;
2318 return EXCEPTION_CONTINUE_EXECUTION;
2319 }
2320 }
2321
2322 if (prev_uef_handler != NULL) {
2323 // We didn't handle this exception so pass it to the previous
2324 // UnhandledExceptionFilter.
2325 return (prev_uef_handler)(exceptionInfo);
2326 }
2327 #else // !_WIN64
2328 // On Windows, the mxcsr control bits are non-volatile across calls
2329 // See also CR 6192333
2330 //
2331 jint MxCsr = INITIAL_MXCSR;
2332 // we can't use StubRoutines::addr_mxcsr_std()
2333 // because in Win64 mxcsr is not saved there
2334 if (MxCsr != ctx->MxCsr) {
2335 ctx->MxCsr = MxCsr;
2336 return EXCEPTION_CONTINUE_EXECUTION;
2337 }
2338 #endif // !_WIN64
2339
2340 return EXCEPTION_CONTINUE_SEARCH;
2341 }
2342
2343 static inline void report_error(Thread* t, DWORD exception_code,
2344 address addr, void* siginfo, void* context) {
2345 VMError::report_and_die(t, exception_code, addr, siginfo, context);
2346
2347 // If UseOsErrorReporting, this will return here and save the error file
2348 // somewhere where we can find it in the minidump.
2349 }
2350
2351 bool os::win32::get_frame_at_stack_banging_point(JavaThread* thread,
2352 struct _EXCEPTION_POINTERS* exceptionInfo, address pc, frame* fr) {
2353 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2354 address addr = (address) exceptionRecord->ExceptionInformation[1];
2355 if (Interpreter::contains(pc)) {
2356 *fr = os::fetch_frame_from_context((void*)exceptionInfo->ContextRecord);
2357 if (!fr->is_first_java_frame()) {
2358 assert(fr->safe_for_sender(thread), "Safety check");
2359 *fr = fr->java_sender();
2360 }
2361 } else {
2362 // more complex code with compiled code
2363 assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above");
2364 CodeBlob* cb = CodeCache::find_blob(pc);
2365 if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) {
2366 // Not sure where the pc points to, fallback to default
2367 // stack overflow handling
2368 return false;
2369 } else {
2370 *fr = os::fetch_frame_from_context((void*)exceptionInfo->ContextRecord);
2371 // in compiled code, the stack banging is performed just after the return pc
2372 // has been pushed on the stack
2373 *fr = frame(fr->sp() + 1, fr->fp(), (address)*(fr->sp()));
2374 if (!fr->is_java_frame()) {
2375 assert(fr->safe_for_sender(thread), "Safety check");
2376 *fr = fr->java_sender();
2377 }
2378 }
2379 }
2380 assert(fr->is_java_frame(), "Safety check");
2381 return true;
2382 }
2383
2384 //-----------------------------------------------------------------------------
2385 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2386 if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2387 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2388 #ifdef _M_IA64
2389 // On Itanium, we need the "precise pc", which has the slot number coded
2390 // into the least 4 bits: 0000=slot0, 0100=slot1, 1000=slot2 (Windows format).
2391 address pc = (address) exceptionInfo->ExceptionRecord->ExceptionAddress;
2392 // Convert the pc to "Unix format", which has the slot number coded
2393 // into the least 2 bits: 0000=slot0, 0001=slot1, 0010=slot2
2394 // This is needed for IA64 because "relocation" / "implicit null check" / "poll instruction"
2395 // information is saved in the Unix format.
2396 address pc_unix_format = (address) ((((uint64_t)pc) & 0xFFFFFFFFFFFFFFF0) | ((((uint64_t)pc) & 0xF) >> 2));
2397 #else
2398 #ifdef _M_AMD64
2399 address pc = (address) exceptionInfo->ContextRecord->Rip;
2400 #else
2401 address pc = (address) exceptionInfo->ContextRecord->Eip;
2402 #endif
2403 #endif
2404 Thread* t = Thread::current_or_null_safe();
2405
2406 // Handle SafeFetch32 and SafeFetchN exceptions.
2407 if (StubRoutines::is_safefetch_fault(pc)) {
2408 return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc));
2409 }
2410
2411 #ifndef _WIN64
2412 // Execution protection violation - win32 running on AMD64 only
2413 // Handled first to avoid misdiagnosis as a "normal" access violation;
2414 // This is safe to do because we have a new/unique ExceptionInformation
2415 // code for this condition.
2416 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2417 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2418 int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2419 address addr = (address) exceptionRecord->ExceptionInformation[1];
2420
2421 if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2422 int page_size = os::vm_page_size();
2423
2424 // Make sure the pc and the faulting address are sane.
2425 //
2426 // If an instruction spans a page boundary, and the page containing
2427 // the beginning of the instruction is executable but the following
2428 // page is not, the pc and the faulting address might be slightly
2429 // different - we still want to unguard the 2nd page in this case.
2430 //
2431 // 15 bytes seems to be a (very) safe value for max instruction size.
2432 bool pc_is_near_addr =
2433 (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2434 bool instr_spans_page_boundary =
2435 (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2436 (intptr_t) page_size) > 0);
2437
2438 if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2439 static volatile address last_addr =
2440 (address) os::non_memory_address_word();
2441
2442 // In conservative mode, don't unguard unless the address is in the VM
2443 if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2444 (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2445
2446 // Set memory to RWX and retry
2447 address page_start =
2448 (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2449 bool res = os::protect_memory((char*) page_start, page_size,
2450 os::MEM_PROT_RWX);
2451
2452 log_debug(os)("Execution protection violation "
2453 "at " INTPTR_FORMAT
2454 ", unguarding " INTPTR_FORMAT ": %s", p2i(addr),
2455 p2i(page_start), (res ? "success" : os::strerror(errno)));
2456
2457 // Set last_addr so if we fault again at the same address, we don't
2458 // end up in an endless loop.
2459 //
2460 // There are two potential complications here. Two threads trapping
2461 // at the same address at the same time could cause one of the
2462 // threads to think it already unguarded, and abort the VM. Likely
2463 // very rare.
2464 //
2465 // The other race involves two threads alternately trapping at
2466 // different addresses and failing to unguard the page, resulting in
2467 // an endless loop. This condition is probably even more unlikely
2468 // than the first.
2469 //
2470 // Although both cases could be avoided by using locks or thread
2471 // local last_addr, these solutions are unnecessary complication:
2472 // this handler is a best-effort safety net, not a complete solution.
2473 // It is disabled by default and should only be used as a workaround
2474 // in case we missed any no-execute-unsafe VM code.
2475
2476 last_addr = addr;
2477
2478 return EXCEPTION_CONTINUE_EXECUTION;
2479 }
2480 }
2481
2482 // Last unguard failed or not unguarding
2483 tty->print_raw_cr("Execution protection violation");
2484 report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2485 exceptionInfo->ContextRecord);
2486 return EXCEPTION_CONTINUE_SEARCH;
2487 }
2488 }
2489 #endif // _WIN64
2490
2491 // Check to see if we caught the safepoint code in the
2492 // process of write protecting the memory serialization page.
2493 // It write enables the page immediately after protecting it
2494 // so just return.
2495 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2496 JavaThread* thread = (JavaThread*) t;
2497 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2498 address addr = (address) exceptionRecord->ExceptionInformation[1];
2499 if (os::is_memory_serialize_page(thread, addr)) {
2500 // Block current thread until the memory serialize page permission restored.
2501 os::block_on_serialize_page_trap();
2502 return EXCEPTION_CONTINUE_EXECUTION;
2503 }
2504 }
2505
2506 if ((exception_code == EXCEPTION_ACCESS_VIOLATION) &&
2507 VM_Version::is_cpuinfo_segv_addr(pc)) {
2508 // Verify that OS save/restore AVX registers.
2509 return Handle_Exception(exceptionInfo, VM_Version::cpuinfo_cont_addr());
2510 }
2511
2512 if (t != NULL && t->is_Java_thread()) {
2513 JavaThread* thread = (JavaThread*) t;
2514 bool in_java = thread->thread_state() == _thread_in_Java;
2515
2516 // Handle potential stack overflows up front.
2517 if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2518 #ifdef _M_IA64
2519 // Use guard page for register stack.
2520 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2521 address addr = (address) exceptionRecord->ExceptionInformation[1];
2522 // Check for a register stack overflow on Itanium
2523 if (thread->addr_inside_register_stack_red_zone(addr)) {
2524 // Fatal red zone violation happens if the Java program
2525 // catches a StackOverflow error and does so much processing
2526 // that it runs beyond the unprotected yellow guard zone. As
2527 // a result, we are out of here.
2528 fatal("ERROR: Unrecoverable stack overflow happened. JVM will exit.");
2529 } else if(thread->addr_inside_register_stack(addr)) {
2530 // Disable the yellow zone which sets the state that
2531 // we've got a stack overflow problem.
2532 if (thread->stack_yellow_reserved_zone_enabled()) {
2533 thread->disable_stack_yellow_reserved_zone();
2534 }
2535 // Give us some room to process the exception.
2536 thread->disable_register_stack_guard();
2537 // Tracing with +Verbose.
2538 if (Verbose) {
2539 tty->print_cr("SOF Compiled Register Stack overflow at " INTPTR_FORMAT " (SIGSEGV)", pc);
2540 tty->print_cr("Register Stack access at " INTPTR_FORMAT, addr);
2541 tty->print_cr("Register Stack base " INTPTR_FORMAT, thread->register_stack_base());
2542 tty->print_cr("Register Stack [" INTPTR_FORMAT "," INTPTR_FORMAT "]",
2543 thread->register_stack_base(),
2544 thread->register_stack_base() + thread->stack_size());
2545 }
2546
2547 // Reguard the permanent register stack red zone just to be sure.
2548 // We saw Windows silently disabling this without telling us.
2549 thread->enable_register_stack_red_zone();
2550
2551 return Handle_Exception(exceptionInfo,
2552 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2553 }
2554 #endif
2555 if (thread->stack_guards_enabled()) {
2556 if (_thread_in_Java) {
2557 frame fr;
2558 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2559 address addr = (address) exceptionRecord->ExceptionInformation[1];
2560 if (os::win32::get_frame_at_stack_banging_point(thread, exceptionInfo, pc, &fr)) {
2561 assert(fr.is_java_frame(), "Must be a Java frame");
2562 SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr);
2563 }
2564 }
2565 // Yellow zone violation. The o/s has unprotected the first yellow
2566 // zone page for us. Note: must call disable_stack_yellow_zone to
2567 // update the enabled status, even if the zone contains only one page.
2568 thread->disable_stack_yellow_reserved_zone();
2569 // If not in java code, return and hope for the best.
2570 return in_java
2571 ? Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2572 : EXCEPTION_CONTINUE_EXECUTION;
2573 } else {
2574 // Fatal red zone violation.
2575 thread->disable_stack_red_zone();
2576 tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2577 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2578 exceptionInfo->ContextRecord);
2579 return EXCEPTION_CONTINUE_SEARCH;
2580 }
2581 } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2582 // Either stack overflow or null pointer exception.
2583 if (in_java) {
2584 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2585 address addr = (address) exceptionRecord->ExceptionInformation[1];
2586 address stack_end = thread->stack_end();
2587 if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2588 // Stack overflow.
2589 assert(!os::uses_stack_guard_pages(),
2590 "should be caught by red zone code above.");
2591 return Handle_Exception(exceptionInfo,
2592 SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2593 }
2594 // Check for safepoint polling and implicit null
2595 // We only expect null pointers in the stubs (vtable)
2596 // the rest are checked explicitly now.
2597 CodeBlob* cb = CodeCache::find_blob(pc);
2598 if (cb != NULL) {
2599 if (os::is_poll_address(addr)) {
2600 address stub = SharedRuntime::get_poll_stub(pc);
2601 return Handle_Exception(exceptionInfo, stub);
2602 }
2603 }
2604 {
2605 #ifdef _WIN64
2606 // If it's a legal stack address map the entire region in
2607 //
2608 PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2609 address addr = (address) exceptionRecord->ExceptionInformation[1];
2610 if (addr > thread->stack_reserved_zone_base() && addr < thread->stack_base()) {
2611 addr = (address)((uintptr_t)addr &
2612 (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2613 os::commit_memory((char *)addr, thread->stack_base() - addr,
2614 !ExecMem);
2615 return EXCEPTION_CONTINUE_EXECUTION;
2616 } else
2617 #endif
2618 {
2619 // Null pointer exception.
2620 #ifdef _M_IA64
2621 // Process implicit null checks in compiled code. Note: Implicit null checks
2622 // can happen even if "ImplicitNullChecks" is disabled, e.g. in vtable stubs.
2623 if (CodeCache::contains((void*) pc_unix_format) && !MacroAssembler::needs_explicit_null_check((intptr_t) addr)) {
2624 CodeBlob *cb = CodeCache::find_blob_unsafe(pc_unix_format);
2625 // Handle implicit null check in UEP method entry
2626 if (cb && (cb->is_frame_complete_at(pc) ||
2627 (cb->is_nmethod() && ((nmethod *)cb)->inlinecache_check_contains(pc)))) {
2628 if (Verbose) {
2629 intptr_t *bundle_start = (intptr_t*) ((intptr_t) pc_unix_format & 0xFFFFFFFFFFFFFFF0);
2630 tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", pc_unix_format);
2631 tty->print_cr(" to addr " INTPTR_FORMAT, addr);
2632 tty->print_cr(" bundle is " INTPTR_FORMAT " (high), " INTPTR_FORMAT " (low)",
2633 *(bundle_start + 1), *bundle_start);
2634 }
2635 return Handle_Exception(exceptionInfo,
2636 SharedRuntime::continuation_for_implicit_exception(thread, pc_unix_format, SharedRuntime::IMPLICIT_NULL));
2637 }
2638 }
2639
2640 // Implicit null checks were processed above. Hence, we should not reach
2641 // here in the usual case => die!
2642 if (Verbose) tty->print_raw_cr("Access violation, possible null pointer exception");
2643 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2644 exceptionInfo->ContextRecord);
2645 return EXCEPTION_CONTINUE_SEARCH;
2646
2647 #else // !IA64
2648
2649 if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr)) {
2650 address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2651 if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2652 }
2653 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2654 exceptionInfo->ContextRecord);
2655 return EXCEPTION_CONTINUE_SEARCH;
2656 #endif
2657 }
2658 }
2659 }
2660
2661 #ifdef _WIN64
2662 // Special care for fast JNI field accessors.
2663 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2664 // in and the heap gets shrunk before the field access.
2665 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2666 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2667 if (addr != (address)-1) {
2668 return Handle_Exception(exceptionInfo, addr);
2669 }
2670 }
2671 #endif
2672
2673 // Stack overflow or null pointer exception in native code.
2674 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2675 exceptionInfo->ContextRecord);
2676 return EXCEPTION_CONTINUE_SEARCH;
2677 } // /EXCEPTION_ACCESS_VIOLATION
2678 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
2679 #if defined _M_IA64
2680 else if ((exception_code == EXCEPTION_ILLEGAL_INSTRUCTION ||
2681 exception_code == EXCEPTION_ILLEGAL_INSTRUCTION_2)) {
2682 M37 handle_wrong_method_break(0, NativeJump::HANDLE_WRONG_METHOD, PR0);
2683
2684 // Compiled method patched to be non entrant? Following conditions must apply:
2685 // 1. must be first instruction in bundle
2686 // 2. must be a break instruction with appropriate code
2687 if ((((uint64_t) pc & 0x0F) == 0) &&
2688 (((IPF_Bundle*) pc)->get_slot0() == handle_wrong_method_break.bits())) {
2689 return Handle_Exception(exceptionInfo,
2690 (address)SharedRuntime::get_handle_wrong_method_stub());
2691 }
2692 } // /EXCEPTION_ILLEGAL_INSTRUCTION
2693 #endif
2694
2695
2696 if (in_java) {
2697 switch (exception_code) {
2698 case EXCEPTION_INT_DIVIDE_BY_ZERO:
2699 return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2700
2701 case EXCEPTION_INT_OVERFLOW:
2702 return Handle_IDiv_Exception(exceptionInfo);
2703
2704 } // switch
2705 }
2706 if (((thread->thread_state() == _thread_in_Java) ||
2707 (thread->thread_state() == _thread_in_native)) &&
2708 exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) {
2709 LONG result=Handle_FLT_Exception(exceptionInfo);
2710 if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2711 }
2712 }
2713
2714 if (exception_code != EXCEPTION_BREAKPOINT) {
2715 report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2716 exceptionInfo->ContextRecord);
2717 }
2718 return EXCEPTION_CONTINUE_SEARCH;
2719 }
2720
2721 #ifndef _WIN64
2722 // Special care for fast JNI accessors.
2723 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2724 // the heap gets shrunk before the field access.
2725 // Need to install our own structured exception handler since native code may
2726 // install its own.
2727 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2728 DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2729 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2730 address pc = (address) exceptionInfo->ContextRecord->Eip;
2731 address addr = JNI_FastGetField::find_slowcase_pc(pc);
2732 if (addr != (address)-1) {
2733 return Handle_Exception(exceptionInfo, addr);
2734 }
2735 }
2736 return EXCEPTION_CONTINUE_SEARCH;
2737 }
2738
2739 #define DEFINE_FAST_GETFIELD(Return, Fieldname, Result) \
2740 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, \
2741 jobject obj, \
2742 jfieldID fieldID) { \
2743 __try { \
2744 return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, \
2745 obj, \
2746 fieldID); \
2747 } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*) \
2748 _exception_info())) { \
2749 } \
2750 return 0; \
2751 }
2752
2753 DEFINE_FAST_GETFIELD(jboolean, bool, Boolean)
2754 DEFINE_FAST_GETFIELD(jbyte, byte, Byte)
2755 DEFINE_FAST_GETFIELD(jchar, char, Char)
2756 DEFINE_FAST_GETFIELD(jshort, short, Short)
2757 DEFINE_FAST_GETFIELD(jint, int, Int)
2758 DEFINE_FAST_GETFIELD(jlong, long, Long)
2759 DEFINE_FAST_GETFIELD(jfloat, float, Float)
2760 DEFINE_FAST_GETFIELD(jdouble, double, Double)
2761
2762 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2763 switch (type) {
2764 case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2765 case T_BYTE: return (address)jni_fast_GetByteField_wrapper;
2766 case T_CHAR: return (address)jni_fast_GetCharField_wrapper;
2767 case T_SHORT: return (address)jni_fast_GetShortField_wrapper;
2768 case T_INT: return (address)jni_fast_GetIntField_wrapper;
2769 case T_LONG: return (address)jni_fast_GetLongField_wrapper;
2770 case T_FLOAT: return (address)jni_fast_GetFloatField_wrapper;
2771 case T_DOUBLE: return (address)jni_fast_GetDoubleField_wrapper;
2772 default: ShouldNotReachHere();
2773 }
2774 return (address)-1;
2775 }
2776 #endif
2777
2778 // Virtual Memory
2779
2780 int os::vm_page_size() { return os::win32::vm_page_size(); }
2781 int os::vm_allocation_granularity() {
2782 return os::win32::vm_allocation_granularity();
2783 }
2784
2785 // Windows large page support is available on Windows 2003. In order to use
2786 // large page memory, the administrator must first assign additional privilege
2787 // to the user:
2788 // + select Control Panel -> Administrative Tools -> Local Security Policy
2789 // + select Local Policies -> User Rights Assignment
2790 // + double click "Lock pages in memory", add users and/or groups
2791 // + reboot
2792 // Note the above steps are needed for administrator as well, as administrators
2793 // by default do not have the privilege to lock pages in memory.
2794 //
2795 // Note about Windows 2003: although the API supports committing large page
2796 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2797 // scenario, I found through experiment it only uses large page if the entire
2798 // memory region is reserved and committed in a single VirtualAlloc() call.
2799 // This makes Windows large page support more or less like Solaris ISM, in
2800 // that the entire heap must be committed upfront. This probably will change
2801 // in the future, if so the code below needs to be revisited.
2802
2803 #ifndef MEM_LARGE_PAGES
2804 #define MEM_LARGE_PAGES 0x20000000
2805 #endif
2806
2807 static HANDLE _hProcess;
2808 static HANDLE _hToken;
2809
2810 // Container for NUMA node list info
2811 class NUMANodeListHolder {
2812 private:
2813 int *_numa_used_node_list; // allocated below
2814 int _numa_used_node_count;
2815
2816 void free_node_list() {
2817 if (_numa_used_node_list != NULL) {
2818 FREE_C_HEAP_ARRAY(int, _numa_used_node_list);
2819 }
2820 }
2821
2822 public:
2823 NUMANodeListHolder() {
2824 _numa_used_node_count = 0;
2825 _numa_used_node_list = NULL;
2826 // do rest of initialization in build routine (after function pointers are set up)
2827 }
2828
2829 ~NUMANodeListHolder() {
2830 free_node_list();
2831 }
2832
2833 bool build() {
2834 DWORD_PTR proc_aff_mask;
2835 DWORD_PTR sys_aff_mask;
2836 if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2837 ULONG highest_node_number;
2838 if (!GetNumaHighestNodeNumber(&highest_node_number)) return false;
2839 free_node_list();
2840 _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal);
2841 for (unsigned int i = 0; i <= highest_node_number; i++) {
2842 ULONGLONG proc_mask_numa_node;
2843 if (!GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2844 if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2845 _numa_used_node_list[_numa_used_node_count++] = i;
2846 }
2847 }
2848 return (_numa_used_node_count > 1);
2849 }
2850
2851 int get_count() { return _numa_used_node_count; }
2852 int get_node_list_entry(int n) {
2853 // for indexes out of range, returns -1
2854 return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2855 }
2856
2857 } numa_node_list_holder;
2858
2859
2860
2861 static size_t _large_page_size = 0;
2862
2863 static bool request_lock_memory_privilege() {
2864 _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2865 os::current_process_id());
2866
2867 LUID luid;
2868 if (_hProcess != NULL &&
2869 OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2870 LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2871
2872 TOKEN_PRIVILEGES tp;
2873 tp.PrivilegeCount = 1;
2874 tp.Privileges[0].Luid = luid;
2875 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2876
2877 // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2878 // privilege. Check GetLastError() too. See MSDN document.
2879 if (AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2880 (GetLastError() == ERROR_SUCCESS)) {
2881 return true;
2882 }
2883 }
2884
2885 return false;
2886 }
2887
2888 static void cleanup_after_large_page_init() {
2889 if (_hProcess) CloseHandle(_hProcess);
2890 _hProcess = NULL;
2891 if (_hToken) CloseHandle(_hToken);
2892 _hToken = NULL;
2893 }
2894
2895 static bool numa_interleaving_init() {
2896 bool success = false;
2897 bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2898
2899 // print a warning if UseNUMAInterleaving flag is specified on command line
2900 bool warn_on_failure = use_numa_interleaving_specified;
2901 #define WARN(msg) if (warn_on_failure) { warning(msg); }
2902
2903 // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2904 size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2905 NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
2906
2907 if (numa_node_list_holder.build()) {
2908 if (log_is_enabled(Debug, os, cpu)) {
2909 Log(os, cpu) log;
2910 log.debug("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
2911 for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
2912 log.debug(" %d ", numa_node_list_holder.get_node_list_entry(i));
2913 }
2914 }
2915 success = true;
2916 } else {
2917 WARN("Process does not cover multiple NUMA nodes.");
2918 }
2919 if (!success) {
2920 if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2921 }
2922 return success;
2923 #undef WARN
2924 }
2925
2926 // this routine is used whenever we need to reserve a contiguous VA range
2927 // but we need to make separate VirtualAlloc calls for each piece of the range
2928 // Reasons for doing this:
2929 // * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2930 // * UseNUMAInterleaving requires a separate node for each piece
2931 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags,
2932 DWORD prot,
2933 bool should_inject_error = false) {
2934 char * p_buf;
2935 // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2936 size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2937 size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2938
2939 // first reserve enough address space in advance since we want to be
2940 // able to break a single contiguous virtual address range into multiple
2941 // large page commits but WS2003 does not allow reserving large page space
2942 // so we just use 4K pages for reserve, this gives us a legal contiguous
2943 // address space. then we will deallocate that reservation, and re alloc
2944 // using large pages
2945 const size_t size_of_reserve = bytes + chunk_size;
2946 if (bytes > size_of_reserve) {
2947 // Overflowed.
2948 return NULL;
2949 }
2950 p_buf = (char *) VirtualAlloc(addr,
2951 size_of_reserve, // size of Reserve
2952 MEM_RESERVE,
2953 PAGE_READWRITE);
2954 // If reservation failed, return NULL
2955 if (p_buf == NULL) return NULL;
2956 MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
2957 os::release_memory(p_buf, bytes + chunk_size);
2958
2959 // we still need to round up to a page boundary (in case we are using large pages)
2960 // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
2961 // instead we handle this in the bytes_to_rq computation below
2962 p_buf = (char *) align_size_up((size_t)p_buf, page_size);
2963
2964 // now go through and allocate one chunk at a time until all bytes are
2965 // allocated
2966 size_t bytes_remaining = bytes;
2967 // An overflow of align_size_up() would have been caught above
2968 // in the calculation of size_of_reserve.
2969 char * next_alloc_addr = p_buf;
2970 HANDLE hProc = GetCurrentProcess();
2971
2972 #ifdef ASSERT
2973 // Variable for the failure injection
2974 long ran_num = os::random();
2975 size_t fail_after = ran_num % bytes;
2976 #endif
2977
2978 int count=0;
2979 while (bytes_remaining) {
2980 // select bytes_to_rq to get to the next chunk_size boundary
2981
2982 size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
2983 // Note allocate and commit
2984 char * p_new;
2985
2986 #ifdef ASSERT
2987 bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
2988 #else
2989 const bool inject_error_now = false;
2990 #endif
2991
2992 if (inject_error_now) {
2993 p_new = NULL;
2994 } else {
2995 if (!UseNUMAInterleaving) {
2996 p_new = (char *) VirtualAlloc(next_alloc_addr,
2997 bytes_to_rq,
2998 flags,
2999 prot);
3000 } else {
3001 // get the next node to use from the used_node_list
3002 assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
3003 DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
3004 p_new = (char *)VirtualAllocExNuma(hProc, next_alloc_addr, bytes_to_rq, flags, prot, node);
3005 }
3006 }
3007
3008 if (p_new == NULL) {
3009 // Free any allocated pages
3010 if (next_alloc_addr > p_buf) {
3011 // Some memory was committed so release it.
3012 size_t bytes_to_release = bytes - bytes_remaining;
3013 // NMT has yet to record any individual blocks, so it
3014 // need to create a dummy 'reserve' record to match
3015 // the release.
3016 MemTracker::record_virtual_memory_reserve((address)p_buf,
3017 bytes_to_release, CALLER_PC);
3018 os::release_memory(p_buf, bytes_to_release);
3019 }
3020 #ifdef ASSERT
3021 if (should_inject_error) {
3022 log_develop_debug(pagesize)("Reserving pages individually failed.");
3023 }
3024 #endif
3025 return NULL;
3026 }
3027
3028 bytes_remaining -= bytes_to_rq;
3029 next_alloc_addr += bytes_to_rq;
3030 count++;
3031 }
3032 // Although the memory is allocated individually, it is returned as one.
3033 // NMT records it as one block.
3034 if ((flags & MEM_COMMIT) != 0) {
3035 MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC);
3036 } else {
3037 MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC);
3038 }
3039
3040 // made it this far, success
3041 return p_buf;
3042 }
3043
3044
3045
3046 void os::large_page_init() {
3047 if (!UseLargePages) return;
3048
3049 // print a warning if any large page related flag is specified on command line
3050 bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
3051 !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3052 bool success = false;
3053
3054 #define WARN(msg) if (warn_on_failure) { warning(msg); }
3055 if (request_lock_memory_privilege()) {
3056 size_t s = GetLargePageMinimum();
3057 if (s) {
3058 #if defined(IA32) || defined(AMD64)
3059 if (s > 4*M || LargePageSizeInBytes > 4*M) {
3060 WARN("JVM cannot use large pages bigger than 4mb.");
3061 } else {
3062 #endif
3063 if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
3064 _large_page_size = LargePageSizeInBytes;
3065 } else {
3066 _large_page_size = s;
3067 }
3068 success = true;
3069 #if defined(IA32) || defined(AMD64)
3070 }
3071 #endif
3072 } else {
3073 WARN("Large page is not supported by the processor.");
3074 }
3075 } else {
3076 WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
3077 }
3078 #undef WARN
3079
3080 const size_t default_page_size = (size_t) vm_page_size();
3081 if (success && _large_page_size > default_page_size) {
3082 _page_sizes[0] = _large_page_size;
3083 _page_sizes[1] = default_page_size;
3084 _page_sizes[2] = 0;
3085 }
3086
3087 cleanup_after_large_page_init();
3088 UseLargePages = success;
3089 }
3090
3091 // On win32, one cannot release just a part of reserved memory, it's an
3092 // all or nothing deal. When we split a reservation, we must break the
3093 // reservation into two reservations.
3094 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
3095 bool realloc) {
3096 if (size > 0) {
3097 release_memory(base, size);
3098 if (realloc) {
3099 reserve_memory(split, base);
3100 }
3101 if (size != split) {
3102 reserve_memory(size - split, base + split);
3103 }
3104 }
3105 }
3106
3107 // Multiple threads can race in this code but it's not possible to unmap small sections of
3108 // virtual space to get requested alignment, like posix-like os's.
3109 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
3110 char* os::reserve_memory_aligned(size_t size, size_t alignment) {
3111 assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,
3112 "Alignment must be a multiple of allocation granularity (page size)");
3113 assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");
3114
3115 size_t extra_size = size + alignment;
3116 assert(extra_size >= size, "overflow, size is too large to allow alignment");
3117
3118 char* aligned_base = NULL;
3119
3120 do {
3121 char* extra_base = os::reserve_memory(extra_size, NULL, alignment);
3122 if (extra_base == NULL) {
3123 return NULL;
3124 }
3125 // Do manual alignment
3126 aligned_base = (char*) align_size_up((uintptr_t) extra_base, alignment);
3127
3128 os::release_memory(extra_base, extra_size);
3129
3130 aligned_base = os::reserve_memory(size, aligned_base);
3131
3132 } while (aligned_base == NULL);
3133
3134 return aligned_base;
3135 }
3136
3137 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
3138 assert((size_t)addr % os::vm_allocation_granularity() == 0,
3139 "reserve alignment");
3140 assert(bytes % os::vm_page_size() == 0, "reserve page size");
3141 char* res;
3142 // note that if UseLargePages is on, all the areas that require interleaving
3143 // will go thru reserve_memory_special rather than thru here.
3144 bool use_individual = (UseNUMAInterleaving && !UseLargePages);
3145 if (!use_individual) {
3146 res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
3147 } else {
3148 elapsedTimer reserveTimer;
3149 if (Verbose && PrintMiscellaneous) reserveTimer.start();
3150 // in numa interleaving, we have to allocate pages individually
3151 // (well really chunks of NUMAInterleaveGranularity size)
3152 res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
3153 if (res == NULL) {
3154 warning("NUMA page allocation failed");
3155 }
3156 if (Verbose && PrintMiscellaneous) {
3157 reserveTimer.stop();
3158 tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3159 reserveTimer.milliseconds(), reserveTimer.ticks());
3160 }
3161 }
3162 assert(res == NULL || addr == NULL || addr == res,
3163 "Unexpected address from reserve.");
3164
3165 return res;
3166 }
3167
3168 // Reserve memory at an arbitrary address, only if that area is
3169 // available (and not reserved for something else).
3170 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3171 // Windows os::reserve_memory() fails of the requested address range is
3172 // not avilable.
3173 return reserve_memory(bytes, requested_addr);
3174 }
3175
3176 size_t os::large_page_size() {
3177 return _large_page_size;
3178 }
3179
3180 bool os::can_commit_large_page_memory() {
3181 // Windows only uses large page memory when the entire region is reserved
3182 // and committed in a single VirtualAlloc() call. This may change in the
3183 // future, but with Windows 2003 it's not possible to commit on demand.
3184 return false;
3185 }
3186
3187 bool os::can_execute_large_page_memory() {
3188 return true;
3189 }
3190
3191 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr,
3192 bool exec) {
3193 assert(UseLargePages, "only for large pages");
3194
3195 if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3196 return NULL; // Fallback to small pages.
3197 }
3198
3199 const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3200 const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3201
3202 // with large pages, there are two cases where we need to use Individual Allocation
3203 // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3204 // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3205 if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3206 log_debug(pagesize)("Reserving large pages individually.");
3207
3208 char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3209 if (p_buf == NULL) {
3210 // give an appropriate warning message
3211 if (UseNUMAInterleaving) {
3212 warning("NUMA large page allocation failed, UseLargePages flag ignored");
3213 }
3214 if (UseLargePagesIndividualAllocation) {
3215 warning("Individually allocated large pages failed, "
3216 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3217 }
3218 return NULL;
3219 }
3220
3221 return p_buf;
3222
3223 } else {
3224 log_debug(pagesize)("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 log_info(os)("SafePoint Polling address: " INTPTR_FORMAT, p2i(polling_page));
4128
4129 if (!UseMembar) {
4130 address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
4131 guarantee(mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
4132
4133 return_page = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
4134 guarantee(return_page != NULL, "Commit Failed for memory serialize page");
4135
4136 os::set_memory_serialize_page(mem_serialize_page);
4137 log_info(os)("Memory Serialize Page address: " INTPTR_FORMAT, p2i(mem_serialize_page));
4138 }
4139
4140 // Setup Windows Exceptions
4141
4142 // for debugging float code generation bugs
4143 if (ForceFloatExceptions) {
4144 #ifndef _WIN64
4145 static long fp_control_word = 0;
4146 __asm { fstcw fp_control_word }
4147 // see Intel PPro Manual, Vol. 2, p 7-16
4148 const long precision = 0x20;
4149 const long underflow = 0x10;
4150 const long overflow = 0x08;
4151 const long zero_div = 0x04;
4152 const long denorm = 0x02;
4153 const long invalid = 0x01;
4154 fp_control_word |= invalid;
4155 __asm { fldcw fp_control_word }
4156 #endif
4157 }
4158
4159 // If stack_commit_size is 0, windows will reserve the default size,
4160 // but only commit a small portion of it.
4161 size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
4162 size_t default_reserve_size = os::win32::default_stack_size();
4163 size_t actual_reserve_size = stack_commit_size;
4164 if (stack_commit_size < default_reserve_size) {
4165 // If stack_commit_size == 0, we want this too
4166 actual_reserve_size = default_reserve_size;
4167 }
4168
4169 // Check minimum allowable stack size for thread creation and to initialize
4170 // the java system classes, including StackOverflowError - depends on page
4171 // size. Add a page for compiler2 recursion in main thread.
4172 // Add in 2*BytesPerWord times page size to account for VM stack during
4173 // class initialization depending on 32 or 64 bit VM.
4174 size_t min_stack_allowed =
4175 (size_t)(JavaThread::stack_yellow_zone_size() + JavaThread::stack_red_zone_size() +
4176 JavaThread::stack_shadow_zone_size() +
4177 (2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size());
4178 if (actual_reserve_size < min_stack_allowed) {
4179 tty->print_cr("\nThe stack size specified is too small, "
4180 "Specify at least %dk",
4181 min_stack_allowed / K);
4182 return JNI_ERR;
4183 }
4184
4185 JavaThread::set_stack_size_at_create(stack_commit_size);
4186
4187 // Calculate theoretical max. size of Threads to guard gainst artifical
4188 // out-of-memory situations, where all available address-space has been
4189 // reserved by thread stacks.
4190 assert(actual_reserve_size != 0, "Must have a stack");
4191
4192 // Calculate the thread limit when we should start doing Virtual Memory
4193 // banging. Currently when the threads will have used all but 200Mb of space.
4194 //
4195 // TODO: consider performing a similar calculation for commit size instead
4196 // as reserve size, since on a 64-bit platform we'll run into that more
4197 // often than running out of virtual memory space. We can use the
4198 // lower value of the two calculations as the os_thread_limit.
4199 size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
4200 win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
4201
4202 // at exit methods are called in the reverse order of their registration.
4203 // there is no limit to the number of functions registered. atexit does
4204 // not set errno.
4205
4206 if (PerfAllowAtExitRegistration) {
4207 // only register atexit functions if PerfAllowAtExitRegistration is set.
4208 // atexit functions can be delayed until process exit time, which
4209 // can be problematic for embedded VM situations. Embedded VMs should
4210 // call DestroyJavaVM() to assure that VM resources are released.
4211
4212 // note: perfMemory_exit_helper atexit function may be removed in
4213 // the future if the appropriate cleanup code can be added to the
4214 // VM_Exit VMOperation's doit method.
4215 if (atexit(perfMemory_exit_helper) != 0) {
4216 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4217 }
4218 }
4219
4220 #ifndef _WIN64
4221 // Print something if NX is enabled (win32 on AMD64)
4222 NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4223 #endif
4224
4225 // initialize thread priority policy
4226 prio_init();
4227
4228 if (UseNUMA && !ForceNUMA) {
4229 UseNUMA = false; // We don't fully support this yet
4230 }
4231
4232 if (UseNUMAInterleaving) {
4233 // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4234 bool success = numa_interleaving_init();
4235 if (!success) UseNUMAInterleaving = false;
4236 }
4237
4238 if (initSock() != JNI_OK) {
4239 return JNI_ERR;
4240 }
4241
4242 return JNI_OK;
4243 }
4244
4245 // Mark the polling page as unreadable
4246 void os::make_polling_page_unreadable(void) {
4247 DWORD old_status;
4248 if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4249 PAGE_NOACCESS, &old_status)) {
4250 fatal("Could not disable polling page");
4251 }
4252 }
4253
4254 // Mark the polling page as readable
4255 void os::make_polling_page_readable(void) {
4256 DWORD old_status;
4257 if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4258 PAGE_READONLY, &old_status)) {
4259 fatal("Could not enable polling page");
4260 }
4261 }
4262
4263
4264 int os::stat(const char *path, struct stat *sbuf) {
4265 char pathbuf[MAX_PATH];
4266 if (strlen(path) > MAX_PATH - 1) {
4267 errno = ENAMETOOLONG;
4268 return -1;
4269 }
4270 os::native_path(strcpy(pathbuf, path));
4271 int ret = ::stat(pathbuf, sbuf);
4272 if (sbuf != NULL && UseUTCFileTimestamp) {
4273 // Fix for 6539723. st_mtime returned from stat() is dependent on
4274 // the system timezone and so can return different values for the
4275 // same file if/when daylight savings time changes. This adjustment
4276 // makes sure the same timestamp is returned regardless of the TZ.
4277 //
4278 // See:
4279 // http://msdn.microsoft.com/library/
4280 // default.asp?url=/library/en-us/sysinfo/base/
4281 // time_zone_information_str.asp
4282 // and
4283 // http://msdn.microsoft.com/library/default.asp?url=
4284 // /library/en-us/sysinfo/base/settimezoneinformation.asp
4285 //
4286 // NOTE: there is a insidious bug here: If the timezone is changed
4287 // after the call to stat() but before 'GetTimeZoneInformation()', then
4288 // the adjustment we do here will be wrong and we'll return the wrong
4289 // value (which will likely end up creating an invalid class data
4290 // archive). Absent a better API for this, or some time zone locking
4291 // mechanism, we'll have to live with this risk.
4292 TIME_ZONE_INFORMATION tz;
4293 DWORD tzid = GetTimeZoneInformation(&tz);
4294 int daylightBias =
4295 (tzid == TIME_ZONE_ID_DAYLIGHT) ? tz.DaylightBias : tz.StandardBias;
4296 sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
4297 }
4298 return ret;
4299 }
4300
4301
4302 #define FT2INT64(ft) \
4303 ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4304
4305
4306 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4307 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4308 // of a thread.
4309 //
4310 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4311 // the fast estimate available on the platform.
4312
4313 // current_thread_cpu_time() is not optimized for Windows yet
4314 jlong os::current_thread_cpu_time() {
4315 // return user + sys since the cost is the same
4316 return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4317 }
4318
4319 jlong os::thread_cpu_time(Thread* thread) {
4320 // consistent with what current_thread_cpu_time() returns.
4321 return os::thread_cpu_time(thread, true /* user+sys */);
4322 }
4323
4324 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4325 return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4326 }
4327
4328 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4329 // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4330 // If this function changes, os::is_thread_cpu_time_supported() should too
4331 FILETIME CreationTime;
4332 FILETIME ExitTime;
4333 FILETIME KernelTime;
4334 FILETIME UserTime;
4335
4336 if (GetThreadTimes(thread->osthread()->thread_handle(), &CreationTime,
4337 &ExitTime, &KernelTime, &UserTime) == 0) {
4338 return -1;
4339 } else if (user_sys_cpu_time) {
4340 return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4341 } else {
4342 return FT2INT64(UserTime) * 100;
4343 }
4344 }
4345
4346 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4347 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
4348 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
4349 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
4350 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
4351 }
4352
4353 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4354 info_ptr->max_value = ALL_64_BITS; // the max value -- all 64 bits
4355 info_ptr->may_skip_backward = false; // GetThreadTimes returns absolute time
4356 info_ptr->may_skip_forward = false; // GetThreadTimes returns absolute time
4357 info_ptr->kind = JVMTI_TIMER_TOTAL_CPU; // user+system time is returned
4358 }
4359
4360 bool os::is_thread_cpu_time_supported() {
4361 // see os::thread_cpu_time
4362 FILETIME CreationTime;
4363 FILETIME ExitTime;
4364 FILETIME KernelTime;
4365 FILETIME UserTime;
4366
4367 if (GetThreadTimes(GetCurrentThread(), &CreationTime, &ExitTime,
4368 &KernelTime, &UserTime) == 0) {
4369 return false;
4370 } else {
4371 return true;
4372 }
4373 }
4374
4375 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4376 // It does have primitives (PDH API) to get CPU usage and run queue length.
4377 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4378 // If we wanted to implement loadavg on Windows, we have a few options:
4379 //
4380 // a) Query CPU usage and run queue length and "fake" an answer by
4381 // returning the CPU usage if it's under 100%, and the run queue
4382 // length otherwise. It turns out that querying is pretty slow
4383 // on Windows, on the order of 200 microseconds on a fast machine.
4384 // Note that on the Windows the CPU usage value is the % usage
4385 // since the last time the API was called (and the first call
4386 // returns 100%), so we'd have to deal with that as well.
4387 //
4388 // b) Sample the "fake" answer using a sampling thread and store
4389 // the answer in a global variable. The call to loadavg would
4390 // just return the value of the global, avoiding the slow query.
4391 //
4392 // c) Sample a better answer using exponential decay to smooth the
4393 // value. This is basically the algorithm used by UNIX kernels.
4394 //
4395 // Note that sampling thread starvation could affect both (b) and (c).
4396 int os::loadavg(double loadavg[], int nelem) {
4397 return -1;
4398 }
4399
4400
4401 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4402 bool os::dont_yield() {
4403 return DontYieldALot;
4404 }
4405
4406 // This method is a slightly reworked copy of JDK's sysOpen
4407 // from src/windows/hpi/src/sys_api_md.c
4408
4409 int os::open(const char *path, int oflag, int mode) {
4410 char pathbuf[MAX_PATH];
4411
4412 if (strlen(path) > MAX_PATH - 1) {
4413 errno = ENAMETOOLONG;
4414 return -1;
4415 }
4416 os::native_path(strcpy(pathbuf, path));
4417 return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4418 }
4419
4420 FILE* os::open(int fd, const char* mode) {
4421 return ::_fdopen(fd, mode);
4422 }
4423
4424 // Is a (classpath) directory empty?
4425 bool os::dir_is_empty(const char* path) {
4426 WIN32_FIND_DATA fd;
4427 HANDLE f = FindFirstFile(path, &fd);
4428 if (f == INVALID_HANDLE_VALUE) {
4429 return true;
4430 }
4431 FindClose(f);
4432 return false;
4433 }
4434
4435 // create binary file, rewriting existing file if required
4436 int os::create_binary_file(const char* path, bool rewrite_existing) {
4437 int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4438 if (!rewrite_existing) {
4439 oflags |= _O_EXCL;
4440 }
4441 return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4442 }
4443
4444 // return current position of file pointer
4445 jlong os::current_file_offset(int fd) {
4446 return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4447 }
4448
4449 // move file pointer to the specified offset
4450 jlong os::seek_to_file_offset(int fd, jlong offset) {
4451 return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4452 }
4453
4454
4455 jlong os::lseek(int fd, jlong offset, int whence) {
4456 return (jlong) ::_lseeki64(fd, offset, whence);
4457 }
4458
4459 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
4460 OVERLAPPED ov;
4461 DWORD nread;
4462 BOOL result;
4463
4464 ZeroMemory(&ov, sizeof(ov));
4465 ov.Offset = (DWORD)offset;
4466 ov.OffsetHigh = (DWORD)(offset >> 32);
4467
4468 HANDLE h = (HANDLE)::_get_osfhandle(fd);
4469
4470 result = ReadFile(h, (LPVOID)buf, nBytes, &nread, &ov);
4471
4472 return result ? nread : 0;
4473 }
4474
4475
4476 // This method is a slightly reworked copy of JDK's sysNativePath
4477 // from src/windows/hpi/src/path_md.c
4478
4479 // Convert a pathname to native format. On win32, this involves forcing all
4480 // separators to be '\\' rather than '/' (both are legal inputs, but Win95
4481 // sometimes rejects '/') and removing redundant separators. The input path is
4482 // assumed to have been converted into the character encoding used by the local
4483 // system. Because this might be a double-byte encoding, care is taken to
4484 // treat double-byte lead characters correctly.
4485 //
4486 // This procedure modifies the given path in place, as the result is never
4487 // longer than the original. There is no error return; this operation always
4488 // succeeds.
4489 char * os::native_path(char *path) {
4490 char *src = path, *dst = path, *end = path;
4491 char *colon = NULL; // If a drive specifier is found, this will
4492 // point to the colon following the drive letter
4493
4494 // Assumption: '/', '\\', ':', and drive letters are never lead bytes
4495 assert(((!::IsDBCSLeadByte('/')) && (!::IsDBCSLeadByte('\\'))
4496 && (!::IsDBCSLeadByte(':'))), "Illegal lead byte");
4497
4498 // Check for leading separators
4499 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4500 while (isfilesep(*src)) {
4501 src++;
4502 }
4503
4504 if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4505 // Remove leading separators if followed by drive specifier. This
4506 // hack is necessary to support file URLs containing drive
4507 // specifiers (e.g., "file://c:/path"). As a side effect,
4508 // "/c:/path" can be used as an alternative to "c:/path".
4509 *dst++ = *src++;
4510 colon = dst;
4511 *dst++ = ':';
4512 src++;
4513 } else {
4514 src = path;
4515 if (isfilesep(src[0]) && isfilesep(src[1])) {
4516 // UNC pathname: Retain first separator; leave src pointed at
4517 // second separator so that further separators will be collapsed
4518 // into the second separator. The result will be a pathname
4519 // beginning with "\\\\" followed (most likely) by a host name.
4520 src = dst = path + 1;
4521 path[0] = '\\'; // Force first separator to '\\'
4522 }
4523 }
4524
4525 end = dst;
4526
4527 // Remove redundant separators from remainder of path, forcing all
4528 // separators to be '\\' rather than '/'. Also, single byte space
4529 // characters are removed from the end of the path because those
4530 // are not legal ending characters on this operating system.
4531 //
4532 while (*src != '\0') {
4533 if (isfilesep(*src)) {
4534 *dst++ = '\\'; src++;
4535 while (isfilesep(*src)) src++;
4536 if (*src == '\0') {
4537 // Check for trailing separator
4538 end = dst;
4539 if (colon == dst - 2) break; // "z:\\"
4540 if (dst == path + 1) break; // "\\"
4541 if (dst == path + 2 && isfilesep(path[0])) {
4542 // "\\\\" is not collapsed to "\\" because "\\\\" marks the
4543 // beginning of a UNC pathname. Even though it is not, by
4544 // itself, a valid UNC pathname, we leave it as is in order
4545 // to be consistent with the path canonicalizer as well
4546 // as the win32 APIs, which treat this case as an invalid
4547 // UNC pathname rather than as an alias for the root
4548 // directory of the current drive.
4549 break;
4550 }
4551 end = --dst; // Path does not denote a root directory, so
4552 // remove trailing separator
4553 break;
4554 }
4555 end = dst;
4556 } else {
4557 if (::IsDBCSLeadByte(*src)) { // Copy a double-byte character
4558 *dst++ = *src++;
4559 if (*src) *dst++ = *src++;
4560 end = dst;
4561 } else { // Copy a single-byte character
4562 char c = *src++;
4563 *dst++ = c;
4564 // Space is not a legal ending character
4565 if (c != ' ') end = dst;
4566 }
4567 }
4568 }
4569
4570 *end = '\0';
4571
4572 // For "z:", add "." to work around a bug in the C runtime library
4573 if (colon == dst - 1) {
4574 path[2] = '.';
4575 path[3] = '\0';
4576 }
4577
4578 return path;
4579 }
4580
4581 // This code is a copy of JDK's sysSetLength
4582 // from src/windows/hpi/src/sys_api_md.c
4583
4584 int os::ftruncate(int fd, jlong length) {
4585 HANDLE h = (HANDLE)::_get_osfhandle(fd);
4586 long high = (long)(length >> 32);
4587 DWORD ret;
4588
4589 if (h == (HANDLE)(-1)) {
4590 return -1;
4591 }
4592
4593 ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4594 if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4595 return -1;
4596 }
4597
4598 if (::SetEndOfFile(h) == FALSE) {
4599 return -1;
4600 }
4601
4602 return 0;
4603 }
4604
4605 int os::fileno(FILE* fp) {
4606 return _fileno(fp);
4607 }
4608
4609 // This code is a copy of JDK's sysSync
4610 // from src/windows/hpi/src/sys_api_md.c
4611 // except for the legacy workaround for a bug in Win 98
4612
4613 int os::fsync(int fd) {
4614 HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4615
4616 if ((!::FlushFileBuffers(handle)) &&
4617 (GetLastError() != ERROR_ACCESS_DENIED)) {
4618 // from winerror.h
4619 return -1;
4620 }
4621 return 0;
4622 }
4623
4624 static int nonSeekAvailable(int, long *);
4625 static int stdinAvailable(int, long *);
4626
4627 #define S_ISCHR(mode) (((mode) & _S_IFCHR) == _S_IFCHR)
4628 #define S_ISFIFO(mode) (((mode) & _S_IFIFO) == _S_IFIFO)
4629
4630 // This code is a copy of JDK's sysAvailable
4631 // from src/windows/hpi/src/sys_api_md.c
4632
4633 int os::available(int fd, jlong *bytes) {
4634 jlong cur, end;
4635 struct _stati64 stbuf64;
4636
4637 if (::_fstati64(fd, &stbuf64) >= 0) {
4638 int mode = stbuf64.st_mode;
4639 if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4640 int ret;
4641 long lpbytes;
4642 if (fd == 0) {
4643 ret = stdinAvailable(fd, &lpbytes);
4644 } else {
4645 ret = nonSeekAvailable(fd, &lpbytes);
4646 }
4647 (*bytes) = (jlong)(lpbytes);
4648 return ret;
4649 }
4650 if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4651 return FALSE;
4652 } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4653 return FALSE;
4654 } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4655 return FALSE;
4656 }
4657 *bytes = end - cur;
4658 return TRUE;
4659 } else {
4660 return FALSE;
4661 }
4662 }
4663
4664 // This code is a copy of JDK's nonSeekAvailable
4665 // from src/windows/hpi/src/sys_api_md.c
4666
4667 static int nonSeekAvailable(int fd, long *pbytes) {
4668 // This is used for available on non-seekable devices
4669 // (like both named and anonymous pipes, such as pipes
4670 // connected to an exec'd process).
4671 // Standard Input is a special case.
4672 HANDLE han;
4673
4674 if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4675 return FALSE;
4676 }
4677
4678 if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4679 // PeekNamedPipe fails when at EOF. In that case we
4680 // simply make *pbytes = 0 which is consistent with the
4681 // behavior we get on Solaris when an fd is at EOF.
4682 // The only alternative is to raise an Exception,
4683 // which isn't really warranted.
4684 //
4685 if (::GetLastError() != ERROR_BROKEN_PIPE) {
4686 return FALSE;
4687 }
4688 *pbytes = 0;
4689 }
4690 return TRUE;
4691 }
4692
4693 #define MAX_INPUT_EVENTS 2000
4694
4695 // This code is a copy of JDK's stdinAvailable
4696 // from src/windows/hpi/src/sys_api_md.c
4697
4698 static int stdinAvailable(int fd, long *pbytes) {
4699 HANDLE han;
4700 DWORD numEventsRead = 0; // Number of events read from buffer
4701 DWORD numEvents = 0; // Number of events in buffer
4702 DWORD i = 0; // Loop index
4703 DWORD curLength = 0; // Position marker
4704 DWORD actualLength = 0; // Number of bytes readable
4705 BOOL error = FALSE; // Error holder
4706 INPUT_RECORD *lpBuffer; // Pointer to records of input events
4707
4708 if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4709 return FALSE;
4710 }
4711
4712 // Construct an array of input records in the console buffer
4713 error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4714 if (error == 0) {
4715 return nonSeekAvailable(fd, pbytes);
4716 }
4717
4718 // lpBuffer must fit into 64K or else PeekConsoleInput fails
4719 if (numEvents > MAX_INPUT_EVENTS) {
4720 numEvents = MAX_INPUT_EVENTS;
4721 }
4722
4723 lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4724 if (lpBuffer == NULL) {
4725 return FALSE;
4726 }
4727
4728 error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4729 if (error == 0) {
4730 os::free(lpBuffer);
4731 return FALSE;
4732 }
4733
4734 // Examine input records for the number of bytes available
4735 for (i=0; i<numEvents; i++) {
4736 if (lpBuffer[i].EventType == KEY_EVENT) {
4737
4738 KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4739 &(lpBuffer[i].Event);
4740 if (keyRecord->bKeyDown == TRUE) {
4741 CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4742 curLength++;
4743 if (*keyPressed == '\r') {
4744 actualLength = curLength;
4745 }
4746 }
4747 }
4748 }
4749
4750 if (lpBuffer != NULL) {
4751 os::free(lpBuffer);
4752 }
4753
4754 *pbytes = (long) actualLength;
4755 return TRUE;
4756 }
4757
4758 // Map a block of memory.
4759 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4760 char *addr, size_t bytes, bool read_only,
4761 bool allow_exec) {
4762 HANDLE hFile;
4763 char* base;
4764
4765 hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4766 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4767 if (hFile == NULL) {
4768 log_info(os)("CreateFile() failed: GetLastError->%ld.", GetLastError());
4769 return NULL;
4770 }
4771
4772 if (allow_exec) {
4773 // CreateFileMapping/MapViewOfFileEx can't map executable memory
4774 // unless it comes from a PE image (which the shared archive is not.)
4775 // Even VirtualProtect refuses to give execute access to mapped memory
4776 // that was not previously executable.
4777 //
4778 // Instead, stick the executable region in anonymous memory. Yuck.
4779 // Penalty is that ~4 pages will not be shareable - in the future
4780 // we might consider DLLizing the shared archive with a proper PE
4781 // header so that mapping executable + sharing is possible.
4782
4783 base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4784 PAGE_READWRITE);
4785 if (base == NULL) {
4786 log_info(os)("VirtualAlloc() failed: GetLastError->%ld.", GetLastError());
4787 CloseHandle(hFile);
4788 return NULL;
4789 }
4790
4791 DWORD bytes_read;
4792 OVERLAPPED overlapped;
4793 overlapped.Offset = (DWORD)file_offset;
4794 overlapped.OffsetHigh = 0;
4795 overlapped.hEvent = NULL;
4796 // ReadFile guarantees that if the return value is true, the requested
4797 // number of bytes were read before returning.
4798 bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4799 if (!res) {
4800 log_info(os)("ReadFile() failed: GetLastError->%ld.", GetLastError());
4801 release_memory(base, bytes);
4802 CloseHandle(hFile);
4803 return NULL;
4804 }
4805 } else {
4806 HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4807 NULL /* file_name */);
4808 if (hMap == NULL) {
4809 log_info(os)("CreateFileMapping() failed: GetLastError->%ld.", GetLastError());
4810 CloseHandle(hFile);
4811 return NULL;
4812 }
4813
4814 DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4815 base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4816 (DWORD)bytes, addr);
4817 if (base == NULL) {
4818 log_info(os)("MapViewOfFileEx() failed: GetLastError->%ld.", GetLastError());
4819 CloseHandle(hMap);
4820 CloseHandle(hFile);
4821 return NULL;
4822 }
4823
4824 if (CloseHandle(hMap) == 0) {
4825 log_info(os)("CloseHandle(hMap) failed: GetLastError->%ld.", GetLastError());
4826 CloseHandle(hFile);
4827 return base;
4828 }
4829 }
4830
4831 if (allow_exec) {
4832 DWORD old_protect;
4833 DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4834 bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4835
4836 if (!res) {
4837 log_info(os)("VirtualProtect() failed: GetLastError->%ld.", GetLastError());
4838 // Don't consider this a hard error, on IA32 even if the
4839 // VirtualProtect fails, we should still be able to execute
4840 CloseHandle(hFile);
4841 return base;
4842 }
4843 }
4844
4845 if (CloseHandle(hFile) == 0) {
4846 log_info(os)("CloseHandle(hFile) failed: GetLastError->%ld.", GetLastError());
4847 return base;
4848 }
4849
4850 return base;
4851 }
4852
4853
4854 // Remap a block of memory.
4855 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4856 char *addr, size_t bytes, bool read_only,
4857 bool allow_exec) {
4858 // This OS does not allow existing memory maps to be remapped so we
4859 // have to unmap the memory before we remap it.
4860 if (!os::unmap_memory(addr, bytes)) {
4861 return NULL;
4862 }
4863
4864 // There is a very small theoretical window between the unmap_memory()
4865 // call above and the map_memory() call below where a thread in native
4866 // code may be able to access an address that is no longer mapped.
4867
4868 return os::map_memory(fd, file_name, file_offset, addr, bytes,
4869 read_only, allow_exec);
4870 }
4871
4872
4873 // Unmap a block of memory.
4874 // Returns true=success, otherwise false.
4875
4876 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4877 MEMORY_BASIC_INFORMATION mem_info;
4878 if (VirtualQuery(addr, &mem_info, sizeof(mem_info)) == 0) {
4879 log_info(os)("VirtualQuery() failed: GetLastError->%ld.", GetLastError());
4880 return false;
4881 }
4882
4883 // Executable memory was not mapped using CreateFileMapping/MapViewOfFileEx.
4884 // Instead, executable region was allocated using VirtualAlloc(). See
4885 // pd_map_memory() above.
4886 //
4887 // The following flags should match the 'exec_access' flages used for
4888 // VirtualProtect() in pd_map_memory().
4889 if (mem_info.Protect == PAGE_EXECUTE_READ ||
4890 mem_info.Protect == PAGE_EXECUTE_READWRITE) {
4891 return pd_release_memory(addr, bytes);
4892 }
4893
4894 BOOL result = UnmapViewOfFile(addr);
4895 if (result == 0) {
4896 log_info(os)("UnmapViewOfFile() failed: GetLastError->%ld.", GetLastError());
4897 return false;
4898 }
4899 return true;
4900 }
4901
4902 void os::pause() {
4903 char filename[MAX_PATH];
4904 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4905 jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4906 } else {
4907 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4908 }
4909
4910 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4911 if (fd != -1) {
4912 struct stat buf;
4913 ::close(fd);
4914 while (::stat(filename, &buf) == 0) {
4915 Sleep(100);
4916 }
4917 } else {
4918 jio_fprintf(stderr,
4919 "Could not open pause file '%s', continuing immediately.\n", filename);
4920 }
4921 }
4922
4923 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
4924 assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
4925 }
4926
4927 // See the caveats for this class in os_windows.hpp
4928 // Protects the callback call so that raised OS EXCEPTIONS causes a jump back
4929 // into this method and returns false. If no OS EXCEPTION was raised, returns
4930 // true.
4931 // The callback is supposed to provide the method that should be protected.
4932 //
4933 bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
4934 assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
4935 assert(!WatcherThread::watcher_thread()->has_crash_protection(),
4936 "crash_protection already set?");
4937
4938 bool success = true;
4939 __try {
4940 WatcherThread::watcher_thread()->set_crash_protection(this);
4941 cb.call();
4942 } __except(EXCEPTION_EXECUTE_HANDLER) {
4943 // only for protection, nothing to do
4944 success = false;
4945 }
4946 WatcherThread::watcher_thread()->set_crash_protection(NULL);
4947 return success;
4948 }
4949
4950 // An Event wraps a win32 "CreateEvent" kernel handle.
4951 //
4952 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4953 //
4954 // 1: When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4955 // field, and call CloseHandle() on the win32 event handle. Unpark() would
4956 // need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4957 // In addition, an unpark() operation might fetch the handle field, but the
4958 // event could recycle between the fetch and the SetEvent() operation.
4959 // SetEvent() would either fail because the handle was invalid, or inadvertently work,
4960 // as the win32 handle value had been recycled. In an ideal world calling SetEvent()
4961 // on an stale but recycled handle would be harmless, but in practice this might
4962 // confuse other non-Sun code, so it's not a viable approach.
4963 //
4964 // 2: Once a win32 event handle is associated with an Event, it remains associated
4965 // with the Event. The event handle is never closed. This could be construed
4966 // as handle leakage, but only up to the maximum # of threads that have been extant
4967 // at any one time. This shouldn't be an issue, as windows platforms typically
4968 // permit a process to have hundreds of thousands of open handles.
4969 //
4970 // 3: Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4971 // and release unused handles.
4972 //
4973 // 4: Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4974 // It's not clear, however, that we wouldn't be trading one type of leak for another.
4975 //
4976 // 5. Use an RCU-like mechanism (Read-Copy Update).
4977 // Or perhaps something similar to Maged Michael's "Hazard pointers".
4978 //
4979 // We use (2).
4980 //
4981 // TODO-FIXME:
4982 // 1. Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4983 // 2. Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4984 // to recover from (or at least detect) the dreaded Windows 841176 bug.
4985 // 3. Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4986 // into a single win32 CreateEvent() handle.
4987 //
4988 // Assumption:
4989 // Only one parker can exist on an event, which is why we allocate
4990 // them per-thread. Multiple unparkers can coexist.
4991 //
4992 // _Event transitions in park()
4993 // -1 => -1 : illegal
4994 // 1 => 0 : pass - return immediately
4995 // 0 => -1 : block; then set _Event to 0 before returning
4996 //
4997 // _Event transitions in unpark()
4998 // 0 => 1 : just return
4999 // 1 => 1 : just return
5000 // -1 => either 0 or 1; must signal target thread
5001 // That is, we can safely transition _Event from -1 to either
5002 // 0 or 1.
5003 //
5004 // _Event serves as a restricted-range semaphore.
5005 // -1 : thread is blocked, i.e. there is a waiter
5006 // 0 : neutral: thread is running or ready,
5007 // could have been signaled after a wait started
5008 // 1 : signaled - thread is running or ready
5009 //
5010 // Another possible encoding of _Event would be with
5011 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5012 //
5013
5014 int os::PlatformEvent::park(jlong Millis) {
5015 // Transitions for _Event:
5016 // -1 => -1 : illegal
5017 // 1 => 0 : pass - return immediately
5018 // 0 => -1 : block; then set _Event to 0 before returning
5019
5020 guarantee(_ParkHandle != NULL , "Invariant");
5021 guarantee(Millis > 0 , "Invariant");
5022
5023 // CONSIDER: defer assigning a CreateEvent() handle to the Event until
5024 // the initial park() operation.
5025 // Consider: use atomic decrement instead of CAS-loop
5026
5027 int v;
5028 for (;;) {
5029 v = _Event;
5030 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5031 }
5032 guarantee((v == 0) || (v == 1), "invariant");
5033 if (v != 0) return OS_OK;
5034
5035 // Do this the hard way by blocking ...
5036 // TODO: consider a brief spin here, gated on the success of recent
5037 // spin attempts by this thread.
5038 //
5039 // We decompose long timeouts into series of shorter timed waits.
5040 // Evidently large timo values passed in WaitForSingleObject() are problematic on some
5041 // versions of Windows. See EventWait() for details. This may be superstition. Or not.
5042 // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
5043 // with os::javaTimeNanos(). Furthermore, we assume that spurious returns from
5044 // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
5045 // to happen early in the wait interval. Specifically, after a spurious wakeup (rv ==
5046 // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
5047 // for the already waited time. This policy does not admit any new outcomes.
5048 // In the future, however, we might want to track the accumulated wait time and
5049 // adjust Millis accordingly if we encounter a spurious wakeup.
5050
5051 const int MAXTIMEOUT = 0x10000000;
5052 DWORD rv = WAIT_TIMEOUT;
5053 while (_Event < 0 && Millis > 0) {
5054 DWORD prd = Millis; // set prd = MAX (Millis, MAXTIMEOUT)
5055 if (Millis > MAXTIMEOUT) {
5056 prd = MAXTIMEOUT;
5057 }
5058 rv = ::WaitForSingleObject(_ParkHandle, prd);
5059 assert(rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed");
5060 if (rv == WAIT_TIMEOUT) {
5061 Millis -= prd;
5062 }
5063 }
5064 v = _Event;
5065 _Event = 0;
5066 // see comment at end of os::PlatformEvent::park() below:
5067 OrderAccess::fence();
5068 // If we encounter a nearly simultanous timeout expiry and unpark()
5069 // we return OS_OK indicating we awoke via unpark().
5070 // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
5071 return (v >= 0) ? OS_OK : OS_TIMEOUT;
5072 }
5073
5074 void os::PlatformEvent::park() {
5075 // Transitions for _Event:
5076 // -1 => -1 : illegal
5077 // 1 => 0 : pass - return immediately
5078 // 0 => -1 : block; then set _Event to 0 before returning
5079
5080 guarantee(_ParkHandle != NULL, "Invariant");
5081 // Invariant: Only the thread associated with the Event/PlatformEvent
5082 // may call park().
5083 // Consider: use atomic decrement instead of CAS-loop
5084 int v;
5085 for (;;) {
5086 v = _Event;
5087 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5088 }
5089 guarantee((v == 0) || (v == 1), "invariant");
5090 if (v != 0) return;
5091
5092 // Do this the hard way by blocking ...
5093 // TODO: consider a brief spin here, gated on the success of recent
5094 // spin attempts by this thread.
5095 while (_Event < 0) {
5096 DWORD rv = ::WaitForSingleObject(_ParkHandle, INFINITE);
5097 assert(rv == WAIT_OBJECT_0, "WaitForSingleObject failed");
5098 }
5099
5100 // Usually we'll find _Event == 0 at this point, but as
5101 // an optional optimization we clear it, just in case can
5102 // multiple unpark() operations drove _Event up to 1.
5103 _Event = 0;
5104 OrderAccess::fence();
5105 guarantee(_Event >= 0, "invariant");
5106 }
5107
5108 void os::PlatformEvent::unpark() {
5109 guarantee(_ParkHandle != NULL, "Invariant");
5110
5111 // Transitions for _Event:
5112 // 0 => 1 : just return
5113 // 1 => 1 : just return
5114 // -1 => either 0 or 1; must signal target thread
5115 // That is, we can safely transition _Event from -1 to either
5116 // 0 or 1.
5117 // See also: "Semaphores in Plan 9" by Mullender & Cox
5118 //
5119 // Note: Forcing a transition from "-1" to "1" on an unpark() means
5120 // that it will take two back-to-back park() calls for the owning
5121 // thread to block. This has the benefit of forcing a spurious return
5122 // from the first park() call after an unpark() call which will help
5123 // shake out uses of park() and unpark() without condition variables.
5124
5125 if (Atomic::xchg(1, &_Event) >= 0) return;
5126
5127 ::SetEvent(_ParkHandle);
5128 }
5129
5130
5131 // JSR166
5132 // -------------------------------------------------------
5133
5134 // The Windows implementation of Park is very straightforward: Basic
5135 // operations on Win32 Events turn out to have the right semantics to
5136 // use them directly. We opportunistically resuse the event inherited
5137 // from Monitor.
5138
5139 void Parker::park(bool isAbsolute, jlong time) {
5140 guarantee(_ParkEvent != NULL, "invariant");
5141 // First, demultiplex/decode time arguments
5142 if (time < 0) { // don't wait
5143 return;
5144 } else if (time == 0 && !isAbsolute) {
5145 time = INFINITE;
5146 } else if (isAbsolute) {
5147 time -= os::javaTimeMillis(); // convert to relative time
5148 if (time <= 0) { // already elapsed
5149 return;
5150 }
5151 } else { // relative
5152 time /= 1000000; // Must coarsen from nanos to millis
5153 if (time == 0) { // Wait for the minimal time unit if zero
5154 time = 1;
5155 }
5156 }
5157
5158 JavaThread* thread = JavaThread::current();
5159
5160 // Don't wait if interrupted or already triggered
5161 if (Thread::is_interrupted(thread, false) ||
5162 WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
5163 ResetEvent(_ParkEvent);
5164 return;
5165 } else {
5166 ThreadBlockInVM tbivm(thread);
5167 OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5168 thread->set_suspend_equivalent();
5169
5170 WaitForSingleObject(_ParkEvent, time);
5171 ResetEvent(_ParkEvent);
5172
5173 // If externally suspended while waiting, re-suspend
5174 if (thread->handle_special_suspend_equivalent_condition()) {
5175 thread->java_suspend_self();
5176 }
5177 }
5178 }
5179
5180 void Parker::unpark() {
5181 guarantee(_ParkEvent != NULL, "invariant");
5182 SetEvent(_ParkEvent);
5183 }
5184
5185 // Run the specified command in a separate process. Return its exit value,
5186 // or -1 on failure (e.g. can't create a new process).
5187 int os::fork_and_exec(char* cmd) {
5188 STARTUPINFO si;
5189 PROCESS_INFORMATION pi;
5190
5191 memset(&si, 0, sizeof(si));
5192 si.cb = sizeof(si);
5193 memset(&pi, 0, sizeof(pi));
5194 BOOL rslt = CreateProcess(NULL, // executable name - use command line
5195 cmd, // command line
5196 NULL, // process security attribute
5197 NULL, // thread security attribute
5198 TRUE, // inherits system handles
5199 0, // no creation flags
5200 NULL, // use parent's environment block
5201 NULL, // use parent's starting directory
5202 &si, // (in) startup information
5203 &pi); // (out) process information
5204
5205 if (rslt) {
5206 // Wait until child process exits.
5207 WaitForSingleObject(pi.hProcess, INFINITE);
5208
5209 DWORD exit_code;
5210 GetExitCodeProcess(pi.hProcess, &exit_code);
5211
5212 // Close process and thread handles.
5213 CloseHandle(pi.hProcess);
5214 CloseHandle(pi.hThread);
5215
5216 return (int)exit_code;
5217 } else {
5218 return -1;
5219 }
5220 }
5221
5222 //--------------------------------------------------------------------------------------------------
5223 // Non-product code
5224
5225 static int mallocDebugIntervalCounter = 0;
5226 static int mallocDebugCounter = 0;
5227 bool os::check_heap(bool force) {
5228 if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
5229 if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
5230 // Note: HeapValidate executes two hardware breakpoints when it finds something
5231 // wrong; at these points, eax contains the address of the offending block (I think).
5232 // To get to the exlicit error message(s) below, just continue twice.
5233 //
5234 // Note: we want to check the CRT heap, which is not necessarily located in the
5235 // process default heap.
5236 HANDLE heap = (HANDLE) _get_heap_handle();
5237 if (!heap) {
5238 return true;
5239 }
5240
5241 // If we fail to lock the heap, then gflags.exe has been used
5242 // or some other special heap flag has been set that prevents
5243 // locking. We don't try to walk a heap we can't lock.
5244 if (HeapLock(heap) != 0) {
5245 PROCESS_HEAP_ENTRY phe;
5246 phe.lpData = NULL;
5247 while (HeapWalk(heap, &phe) != 0) {
5248 if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
5249 !HeapValidate(heap, 0, phe.lpData)) {
5250 tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
5251 tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
5252 HeapUnlock(heap);
5253 fatal("corrupted C heap");
5254 }
5255 }
5256 DWORD err = GetLastError();
5257 if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
5258 HeapUnlock(heap);
5259 fatal("heap walk aborted with error %d", err);
5260 }
5261 HeapUnlock(heap);
5262 }
5263 mallocDebugIntervalCounter = 0;
5264 }
5265 return true;
5266 }
5267
5268
5269 bool os::find(address addr, outputStream* st) {
5270 int offset = -1;
5271 bool result = false;
5272 char buf[256];
5273 if (os::dll_address_to_library_name(addr, buf, sizeof(buf), &offset)) {
5274 st->print(PTR_FORMAT " ", addr);
5275 if (strlen(buf) < sizeof(buf) - 1) {
5276 char* p = strrchr(buf, '\\');
5277 if (p) {
5278 st->print("%s", p + 1);
5279 } else {
5280 st->print("%s", buf);
5281 }
5282 } else {
5283 // The library name is probably truncated. Let's omit the library name.
5284 // See also JDK-8147512.
5285 }
5286 if (os::dll_address_to_function_name(addr, buf, sizeof(buf), &offset)) {
5287 st->print("::%s + 0x%x", buf, offset);
5288 }
5289 st->cr();
5290 result = true;
5291 }
5292 return result;
5293 }
5294
5295 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5296 DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5297
5298 if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
5299 JavaThread* thread = JavaThread::current();
5300 PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5301 address addr = (address) exceptionRecord->ExceptionInformation[1];
5302
5303 if (os::is_memory_serialize_page(thread, addr)) {
5304 return EXCEPTION_CONTINUE_EXECUTION;
5305 }
5306 }
5307
5308 return EXCEPTION_CONTINUE_SEARCH;
5309 }
5310
5311 // We don't build a headless jre for Windows
5312 bool os::is_headless_jre() { return false; }
5313
5314 static jint initSock() {
5315 WSADATA wsadata;
5316
5317 if (WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5318 jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5319 ::GetLastError());
5320 return JNI_ERR;
5321 }
5322 return JNI_OK;
5323 }
5324
5325 struct hostent* os::get_host_by_name(char* name) {
5326 return (struct hostent*)gethostbyname(name);
5327 }
5328
5329 int os::socket_close(int fd) {
5330 return ::closesocket(fd);
5331 }
5332
5333 int os::socket(int domain, int type, int protocol) {
5334 return ::socket(domain, type, protocol);
5335 }
5336
5337 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5338 return ::connect(fd, him, len);
5339 }
5340
5341 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5342 return ::recv(fd, buf, (int)nBytes, flags);
5343 }
5344
5345 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5346 return ::send(fd, buf, (int)nBytes, flags);
5347 }
5348
5349 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5350 return ::send(fd, buf, (int)nBytes, flags);
5351 }
5352
5353 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5354 #if defined(IA32)
5355 #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5356 #elif defined (AMD64)
5357 #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5358 #endif
5359
5360 // returns true if thread could be suspended,
5361 // false otherwise
5362 static bool do_suspend(HANDLE* h) {
5363 if (h != NULL) {
5364 if (SuspendThread(*h) != ~0) {
5365 return true;
5366 }
5367 }
5368 return false;
5369 }
5370
5371 // resume the thread
5372 // calling resume on an active thread is a no-op
5373 static void do_resume(HANDLE* h) {
5374 if (h != NULL) {
5375 ResumeThread(*h);
5376 }
5377 }
5378
5379 // retrieve a suspend/resume context capable handle
5380 // from the tid. Caller validates handle return value.
5381 void get_thread_handle_for_extended_context(HANDLE* h,
5382 OSThread::thread_id_t tid) {
5383 if (h != NULL) {
5384 *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5385 }
5386 }
5387
5388 // Thread sampling implementation
5389 //
5390 void os::SuspendedThreadTask::internal_do_task() {
5391 CONTEXT ctxt;
5392 HANDLE h = NULL;
5393
5394 // get context capable handle for thread
5395 get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5396
5397 // sanity
5398 if (h == NULL || h == INVALID_HANDLE_VALUE) {
5399 return;
5400 }
5401
5402 // suspend the thread
5403 if (do_suspend(&h)) {
5404 ctxt.ContextFlags = sampling_context_flags;
5405 // get thread context
5406 GetThreadContext(h, &ctxt);
5407 SuspendedThreadTaskContext context(_thread, &ctxt);
5408 // pass context to Thread Sampling impl
5409 do_task(context);
5410 // resume thread
5411 do_resume(&h);
5412 }
5413
5414 // close handle
5415 CloseHandle(h);
5416 }
5417
5418 bool os::start_debugging(char *buf, int buflen) {
5419 int len = (int)strlen(buf);
5420 char *p = &buf[len];
5421
5422 jio_snprintf(p, buflen-len,
5423 "\n\n"
5424 "Do you want to debug the problem?\n\n"
5425 "To debug, attach Visual Studio to process %d; then switch to thread 0x%x\n"
5426 "Select 'Yes' to launch Visual Studio automatically (PATH must include msdev)\n"
5427 "Otherwise, select 'No' to abort...",
5428 os::current_process_id(), os::current_thread_id());
5429
5430 bool yes = os::message_box("Unexpected Error", buf);
5431
5432 if (yes) {
5433 // os::breakpoint() calls DebugBreak(), which causes a breakpoint
5434 // exception. If VM is running inside a debugger, the debugger will
5435 // catch the exception. Otherwise, the breakpoint exception will reach
5436 // the default windows exception handler, which can spawn a debugger and
5437 // automatically attach to the dying VM.
5438 os::breakpoint();
5439 yes = false;
5440 }
5441 return yes;
5442 }
5443
5444 void* os::get_default_process_handle() {
5445 return (void*)GetModuleHandle(NULL);
5446 }
5447
5448 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
5449 // which is used to find statically linked in agents.
5450 // Additionally for windows, takes into account __stdcall names.
5451 // Parameters:
5452 // sym_name: Symbol in library we are looking for
5453 // lib_name: Name of library to look in, NULL for shared libs.
5454 // is_absolute_path == true if lib_name is absolute path to agent
5455 // such as "C:/a/b/L.dll"
5456 // == false if only the base name of the library is passed in
5457 // such as "L"
5458 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
5459 bool is_absolute_path) {
5460 char *agent_entry_name;
5461 size_t len;
5462 size_t name_len;
5463 size_t prefix_len = strlen(JNI_LIB_PREFIX);
5464 size_t suffix_len = strlen(JNI_LIB_SUFFIX);
5465 const char *start;
5466
5467 if (lib_name != NULL) {
5468 len = name_len = strlen(lib_name);
5469 if (is_absolute_path) {
5470 // Need to strip path, prefix and suffix
5471 if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
5472 lib_name = ++start;
5473 } else {
5474 // Need to check for drive prefix
5475 if ((start = strchr(lib_name, ':')) != NULL) {
5476 lib_name = ++start;
5477 }
5478 }
5479 if (len <= (prefix_len + suffix_len)) {
5480 return NULL;
5481 }
5482 lib_name += prefix_len;
5483 name_len = strlen(lib_name) - suffix_len;
5484 }
5485 }
5486 len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
5487 agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
5488 if (agent_entry_name == NULL) {
5489 return NULL;
5490 }
5491 if (lib_name != NULL) {
5492 const char *p = strrchr(sym_name, '@');
5493 if (p != NULL && p != sym_name) {
5494 // sym_name == _Agent_OnLoad@XX
5495 strncpy(agent_entry_name, sym_name, (p - sym_name));
5496 agent_entry_name[(p-sym_name)] = '\0';
5497 // agent_entry_name == _Agent_OnLoad
5498 strcat(agent_entry_name, "_");
5499 strncat(agent_entry_name, lib_name, name_len);
5500 strcat(agent_entry_name, p);
5501 // agent_entry_name == _Agent_OnLoad_lib_name@XX
5502 } else {
5503 strcpy(agent_entry_name, sym_name);
5504 strcat(agent_entry_name, "_");
5505 strncat(agent_entry_name, lib_name, name_len);
5506 }
5507 } else {
5508 strcpy(agent_entry_name, sym_name);
5509 }
5510 return agent_entry_name;
5511 }
5512
5513 #ifndef PRODUCT
5514
5515 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5516 // contiguous memory block at a particular address.
5517 // The test first tries to find a good approximate address to allocate at by using the same
5518 // method to allocate some memory at any address. The test then tries to allocate memory in
5519 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5520 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5521 // the previously allocated memory is available for allocation. The only actual failure
5522 // that is reported is when the test tries to allocate at a particular location but gets a
5523 // different valid one. A NULL return value at this point is not considered an error but may
5524 // be legitimate.
5525 // If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages.
5526 void TestReserveMemorySpecial_test() {
5527 if (!UseLargePages) {
5528 if (VerboseInternalVMTests) {
5529 tty->print("Skipping test because large pages are disabled");
5530 }
5531 return;
5532 }
5533 // save current value of globals
5534 bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5535 bool old_use_numa_interleaving = UseNUMAInterleaving;
5536
5537 // set globals to make sure we hit the correct code path
5538 UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5539
5540 // do an allocation at an address selected by the OS to get a good one.
5541 const size_t large_allocation_size = os::large_page_size() * 4;
5542 char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5543 if (result == NULL) {
5544 if (VerboseInternalVMTests) {
5545 tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
5546 large_allocation_size);
5547 }
5548 } else {
5549 os::release_memory_special(result, large_allocation_size);
5550
5551 // allocate another page within the recently allocated memory area which seems to be a good location. At least
5552 // we managed to get it once.
5553 const size_t expected_allocation_size = os::large_page_size();
5554 char* expected_location = result + os::large_page_size();
5555 char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5556 if (actual_location == NULL) {
5557 if (VerboseInternalVMTests) {
5558 tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
5559 expected_location, large_allocation_size);
5560 }
5561 } else {
5562 // release memory
5563 os::release_memory_special(actual_location, expected_allocation_size);
5564 // only now check, after releasing any memory to avoid any leaks.
5565 assert(actual_location == expected_location,
5566 "Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
5567 expected_location, expected_allocation_size, actual_location);
5568 }
5569 }
5570
5571 // restore globals
5572 UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5573 UseNUMAInterleaving = old_use_numa_interleaving;
5574 }
5575 #endif // PRODUCT
5576
5577 /*
5578 All the defined signal names for Windows.
5579
5580 NOTE that not all of these names are accepted by FindSignal!
5581
5582 For various reasons some of these may be rejected at runtime.
5583
5584 Here are the names currently accepted by a user of sun.misc.Signal with
5585 1.4.1 (ignoring potential interaction with use of chaining, etc):
5586
5587 (LIST TBD)
5588
5589 */
5590 int os::get_signal_number(const char* name) {
5591 static const struct {
5592 char* name;
5593 int number;
5594 } siglabels [] =
5595 // derived from version 6.0 VC98/include/signal.h
5596 {"ABRT", SIGABRT, // abnormal termination triggered by abort cl
5597 "FPE", SIGFPE, // floating point exception
5598 "SEGV", SIGSEGV, // segment violation
5599 "INT", SIGINT, // interrupt
5600 "TERM", SIGTERM, // software term signal from kill
5601 "BREAK", SIGBREAK, // Ctrl-Break sequence
5602 "ILL", SIGILL}; // illegal instruction
5603 for (unsigned i = 0; i < ARRAY_SIZE(siglabels); ++i) {
5604 if (strcmp(name, siglabels[i].name) == 0) {
5605 return siglabels[i].number;
5606 }
5607 }
5608 return -1;
5609 }
5610
5611 // Fast current thread access
5612
5613 int os::win32::_thread_ptr_offset = 0;
5614
5615 static void call_wrapper_dummy() {}
5616
5617 // We need to call the os_exception_wrapper once so that it sets
5618 // up the offset from FS of the thread pointer.
5619 void os::win32::initialize_thread_ptr_offset() {
5620 os::os_exception_wrapper((java_call_t)call_wrapper_dummy,
5621 NULL, NULL, NULL, NULL);
5622 }