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