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