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