1 /*
   2  * Copyright (c) 1997, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // Must be at least Windows Vista or Server 2008 to use InitOnceExecuteOnce
  26 #define _WIN32_WINNT 0x0600
  27 
  28 // no precompiled headers
  29 #include "jvm.h"
  30 #include "classfile/classLoader.hpp"
  31 #include "classfile/systemDictionary.hpp"
  32 #include "classfile/vmSymbols.hpp"
  33 #include "code/icBuffer.hpp"
  34 #include "code/vtableStubs.hpp"
  35 #include "compiler/compileBroker.hpp"
  36 #include "compiler/disassembler.hpp"
  37 #include "interpreter/interpreter.hpp"
  38 #include "logging/log.hpp"
  39 #include "memory/allocation.inline.hpp"
  40 #include "memory/filemap.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "os_share_windows.hpp"
  43 #include "os_windows.inline.hpp"
  44 #include "prims/jniFastGetField.hpp"
  45 #include "prims/jvm_misc.hpp"
  46 #include "runtime/arguments.hpp"
  47 #include "runtime/atomic.hpp"
  48 #include "runtime/extendedPC.hpp"
  49 #include "runtime/globals.hpp"
  50 #include "runtime/interfaceSupport.inline.hpp"
  51 #include "runtime/java.hpp"
  52 #include "runtime/javaCalls.hpp"
  53 #include "runtime/mutexLocker.hpp"
  54 #include "runtime/objectMonitor.hpp"
  55 #include "runtime/orderAccess.hpp"
  56 #include "runtime/osThread.hpp"
  57 #include "runtime/perfMemory.hpp"
  58 #include "runtime/sharedRuntime.hpp"
  59 #include "runtime/statSampler.hpp"
  60 #include "runtime/stubRoutines.hpp"
  61 #include "runtime/thread.inline.hpp"
  62 #include "runtime/threadCritical.hpp"
  63 #include "runtime/timer.hpp"
  64 #include "runtime/vm_version.hpp"
  65 #include "services/attachListener.hpp"
  66 #include "services/memTracker.hpp"
  67 #include "services/runtimeService.hpp"
  68 #include "utilities/align.hpp"
  69 #include "utilities/decoder.hpp"
  70 #include "utilities/defaultStream.hpp"
  71 #include "utilities/events.hpp"
  72 #include "utilities/growableArray.hpp"
  73 #include "utilities/macros.hpp"
  74 #include "utilities/vmError.hpp"
  75 #include "symbolengine.hpp"
  76 #include "windbghelp.hpp"
  77 
  78 
  79 #ifdef _DEBUG
  80 #include <crtdbg.h>
  81 #endif
  82 
  83 
  84 #include <windows.h>
  85 #include <sys/types.h>
  86 #include <sys/stat.h>
  87 #include <sys/timeb.h>
  88 #include <objidl.h>
  89 #include <shlobj.h>
  90 
  91 #include <malloc.h>
  92 #include <signal.h>
  93 #include <direct.h>
  94 #include <errno.h>
  95 #include <fcntl.h>
  96 #include <io.h>
  97 #include <process.h>              // For _beginthreadex(), _endthreadex()
  98 #include <imagehlp.h>             // For os::dll_address_to_function_name
  99 // for enumerating dll libraries
 100 #include <vdmdbg.h>
 101 #include <psapi.h>
 102 #include <mmsystem.h>
 103 #include <winsock2.h>
 104 
 105 // for timer info max values which include all bits
 106 #define ALL_64_BITS CONST64(-1)
 107 
 108 // For DLL loading/load error detection
 109 // Values of PE COFF
 110 #define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c
 111 #define IMAGE_FILE_SIGNATURE_LENGTH 4
 112 
 113 static HANDLE main_process;
 114 static HANDLE main_thread;
 115 static int    main_thread_id;
 116 
 117 static FILETIME process_creation_time;
 118 static FILETIME process_exit_time;
 119 static FILETIME process_user_time;
 120 static FILETIME process_kernel_time;
 121 
 122 #ifdef _M_AMD64
 123   #define __CPU__ amd64
 124 #else
 125   #define __CPU__ i486
 126 #endif
 127 
 128 // save DLL module handle, used by GetModuleFileName
 129 
 130 HINSTANCE vm_lib_handle;
 131 
 132 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
 133   switch (reason) {
 134   case DLL_PROCESS_ATTACH:
 135     vm_lib_handle = hinst;
 136     if (ForceTimeHighResolution) {
 137       timeBeginPeriod(1L);
 138     }
 139     WindowsDbgHelp::pre_initialize();
 140     SymbolEngine::pre_initialize();
 141     break;
 142   case DLL_PROCESS_DETACH:
 143     if (ForceTimeHighResolution) {
 144       timeEndPeriod(1L);
 145     }
 146     break;
 147   default:
 148     break;
 149   }
 150   return true;
 151 }
 152 
 153 static inline double fileTimeAsDouble(FILETIME* time) {
 154   const double high  = (double) ((unsigned int) ~0);
 155   const double split = 10000000.0;
 156   double result = (time->dwLowDateTime / split) +
 157                    time->dwHighDateTime * (high/split);
 158   return result;
 159 }
 160 
 161 // Implementation of os
 162 
 163 bool os::unsetenv(const char* name) {
 164   assert(name != NULL, "Null pointer");
 165   return (SetEnvironmentVariable(name, NULL) == TRUE);
 166 }
 167 
 168 // No setuid programs under Windows.
 169 bool os::have_special_privileges() {
 170   return false;
 171 }
 172 
 173 
 174 // This method is  a periodic task to check for misbehaving JNI applications
 175 // under CheckJNI, we can add any periodic checks here.
 176 // For Windows at the moment does nothing
 177 void os::run_periodic_checks() {
 178   return;
 179 }
 180 
 181 // previous UnhandledExceptionFilter, if there is one
 182 static LPTOP_LEVEL_EXCEPTION_FILTER prev_uef_handler = NULL;
 183 
 184 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo);
 185 
 186 void os::init_system_properties_values() {
 187   // sysclasspath, java_home, dll_dir
 188   {
 189     char *home_path;
 190     char *dll_path;
 191     char *pslash;
 192     char *bin = "\\bin";
 193     char home_dir[MAX_PATH + 1];
 194     char *alt_home_dir = ::getenv("_ALT_JAVA_HOME_DIR");
 195 
 196     if (alt_home_dir != NULL)  {
 197       strncpy(home_dir, alt_home_dir, MAX_PATH + 1);
 198       home_dir[MAX_PATH] = '\0';
 199     } else {
 200       os::jvm_path(home_dir, sizeof(home_dir));
 201       // Found the full path to jvm.dll.
 202       // Now cut the path to <java_home>/jre if we can.
 203       *(strrchr(home_dir, '\\')) = '\0';  // get rid of \jvm.dll
 204       pslash = strrchr(home_dir, '\\');
 205       if (pslash != NULL) {
 206         *pslash = '\0';                   // get rid of \{client|server}
 207         pslash = strrchr(home_dir, '\\');
 208         if (pslash != NULL) {
 209           *pslash = '\0';                 // get rid of \bin
 210         }
 211       }
 212     }
 213 
 214     home_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + 1, mtInternal);
 215     if (home_path == NULL) {
 216       return;
 217     }
 218     strcpy(home_path, home_dir);
 219     Arguments::set_java_home(home_path);
 220     FREE_C_HEAP_ARRAY(char, home_path);
 221 
 222     dll_path = NEW_C_HEAP_ARRAY(char, strlen(home_dir) + strlen(bin) + 1,
 223                                 mtInternal);
 224     if (dll_path == NULL) {
 225       return;
 226     }
 227     strcpy(dll_path, home_dir);
 228     strcat(dll_path, bin);
 229     Arguments::set_dll_dir(dll_path);
 230     FREE_C_HEAP_ARRAY(char, dll_path);
 231 
 232     if (!set_boot_path('\\', ';')) {
 233       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   int r1 = GlobalMemoryStatusEx(&ms);
1749 
1750   if (r1 != 0) {
1751     st->print(", system-wide physical " INT64_FORMAT "M ",
1752              (int64_t) ms.ullTotalPhys >> 20);
1753     st->print("(" INT64_FORMAT "M free)\n", (int64_t) ms.ullAvailPhys >> 20);
1754 
1755     st->print("TotalPageFile size " INT64_FORMAT "M ",
1756              (int64_t) ms.ullTotalPageFile >> 20);
1757     st->print("(AvailPageFile size " INT64_FORMAT "M)",
1758              (int64_t) ms.ullAvailPageFile >> 20);
1759 
1760     // on 32bit Total/AvailVirtual are interesting (show us how close we get to 2-4 GB per process borders)
1761 #if defined(_M_IX86)
1762     st->print(", user-mode portion of virtual address-space " INT64_FORMAT "M ",
1763              (int64_t) ms.ullTotalVirtual >> 20);
1764     st->print("(" INT64_FORMAT "M free)", (int64_t) ms.ullAvailVirtual >> 20);
1765 #endif
1766   } else {
1767     st->print(", GlobalMemoryStatusEx did not succeed so we miss some memory values.");
1768   }
1769 
1770   // extended memory statistics for a process
1771   PROCESS_MEMORY_COUNTERS_EX pmex;
1772   ZeroMemory(&pmex, sizeof(PROCESS_MEMORY_COUNTERS_EX));
1773   pmex.cb = sizeof(pmex);
1774   int r2 = GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*) &pmex, sizeof(pmex));
1775 
1776   if (r2 != 0) {
1777     st->print("\ncurrent process WorkingSet (physical memory assigned to process): " INT64_FORMAT "M, ",
1778              (int64_t) pmex.WorkingSetSize >> 20);
1779     st->print("peak: " INT64_FORMAT "M\n", (int64_t) pmex.PeakWorkingSetSize >> 20);
1780 
1781     st->print("current process commit charge (\"private bytes\"): " INT64_FORMAT "M, ",
1782              (int64_t) pmex.PrivateUsage >> 20);
1783     st->print("peak: " INT64_FORMAT "M", (int64_t) pmex.PeakPagefileUsage >> 20);
1784   } else {
1785     st->print("\nGetProcessMemoryInfo did not succeed so we miss some memory values.");
1786   }
1787 
1788   st->cr();
1789 }
1790 
1791 void os::print_siginfo(outputStream *st, const void* siginfo) {
1792   const EXCEPTION_RECORD* const er = (EXCEPTION_RECORD*)siginfo;
1793   st->print("siginfo:");
1794 
1795   char tmp[64];
1796   if (os::exception_name(er->ExceptionCode, tmp, sizeof(tmp)) == NULL) {
1797     strcpy(tmp, "EXCEPTION_??");
1798   }
1799   st->print(" %s (0x%x)", tmp, er->ExceptionCode);
1800 
1801   if ((er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
1802        er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR) &&
1803        er->NumberParameters >= 2) {
1804     switch (er->ExceptionInformation[0]) {
1805     case 0: st->print(", reading address"); break;
1806     case 1: st->print(", writing address"); break;
1807     case 8: st->print(", data execution prevention violation at address"); break;
1808     default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1809                        er->ExceptionInformation[0]);
1810     }
1811     st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1812   } else {
1813     int num = er->NumberParameters;
1814     if (num > 0) {
1815       st->print(", ExceptionInformation=");
1816       for (int i = 0; i < num; i++) {
1817         st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1818       }
1819     }
1820   }
1821   st->cr();
1822 }
1823 
1824 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1825   // do nothing
1826 }
1827 
1828 static char saved_jvm_path[MAX_PATH] = {0};
1829 
1830 // Find the full path to the current module, jvm.dll
1831 void os::jvm_path(char *buf, jint buflen) {
1832   // Error checking.
1833   if (buflen < MAX_PATH) {
1834     assert(false, "must use a large-enough buffer");
1835     buf[0] = '\0';
1836     return;
1837   }
1838   // Lazy resolve the path to current module.
1839   if (saved_jvm_path[0] != 0) {
1840     strcpy(buf, saved_jvm_path);
1841     return;
1842   }
1843 
1844   buf[0] = '\0';
1845   if (Arguments::sun_java_launcher_is_altjvm()) {
1846     // Support for the java launcher's '-XXaltjvm=<path>' option. Check
1847     // for a JAVA_HOME environment variable and fix up the path so it
1848     // looks like jvm.dll is installed there (append a fake suffix
1849     // hotspot/jvm.dll).
1850     char* java_home_var = ::getenv("JAVA_HOME");
1851     if (java_home_var != NULL && java_home_var[0] != 0 &&
1852         strlen(java_home_var) < (size_t)buflen) {
1853       strncpy(buf, java_home_var, buflen);
1854 
1855       // determine if this is a legacy image or modules image
1856       // modules image doesn't have "jre" subdirectory
1857       size_t len = strlen(buf);
1858       char* jrebin_p = buf + len;
1859       jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1860       if (0 != _access(buf, 0)) {
1861         jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1862       }
1863       len = strlen(buf);
1864       jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1865     }
1866   }
1867 
1868   if (buf[0] == '\0') {
1869     GetModuleFileName(vm_lib_handle, buf, buflen);
1870   }
1871   strncpy(saved_jvm_path, buf, MAX_PATH);
1872   saved_jvm_path[MAX_PATH - 1] = '\0';
1873 }
1874 
1875 
1876 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1877 #ifndef _WIN64
1878   st->print("_");
1879 #endif
1880 }
1881 
1882 
1883 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1884 #ifndef _WIN64
1885   st->print("@%d", args_size  * sizeof(int));
1886 #endif
1887 }
1888 
1889 // This method is a copy of JDK's sysGetLastErrorString
1890 // from src/windows/hpi/src/system_md.c
1891 
1892 size_t os::lasterror(char* buf, size_t len) {
1893   DWORD errval;
1894 
1895   if ((errval = GetLastError()) != 0) {
1896     // DOS error
1897     size_t n = (size_t)FormatMessage(
1898                                      FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
1899                                      NULL,
1900                                      errval,
1901                                      0,
1902                                      buf,
1903                                      (DWORD)len,
1904                                      NULL);
1905     if (n > 3) {
1906       // Drop final '.', CR, LF
1907       if (buf[n - 1] == '\n') n--;
1908       if (buf[n - 1] == '\r') n--;
1909       if (buf[n - 1] == '.') n--;
1910       buf[n] = '\0';
1911     }
1912     return n;
1913   }
1914 
1915   if (errno != 0) {
1916     // C runtime error that has no corresponding DOS error code
1917     const char* s = os::strerror(errno);
1918     size_t n = strlen(s);
1919     if (n >= len) n = len - 1;
1920     strncpy(buf, s, n);
1921     buf[n] = '\0';
1922     return n;
1923   }
1924 
1925   return 0;
1926 }
1927 
1928 int os::get_last_error() {
1929   DWORD error = GetLastError();
1930   if (error == 0) {
1931     error = errno;
1932   }
1933   return (int)error;
1934 }
1935 
1936 // sun.misc.Signal
1937 // NOTE that this is a workaround for an apparent kernel bug where if
1938 // a signal handler for SIGBREAK is installed then that signal handler
1939 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
1940 // See bug 4416763.
1941 static void (*sigbreakHandler)(int) = NULL;
1942 
1943 static void UserHandler(int sig, void *siginfo, void *context) {
1944   os::signal_notify(sig);
1945   // We need to reinstate the signal handler each time...
1946   os::signal(sig, (void*)UserHandler);
1947 }
1948 
1949 void* os::user_handler() {
1950   return (void*) UserHandler;
1951 }
1952 
1953 void* os::signal(int signal_number, void* handler) {
1954   if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
1955     void (*oldHandler)(int) = sigbreakHandler;
1956     sigbreakHandler = (void (*)(int)) handler;
1957     return (void*) oldHandler;
1958   } else {
1959     return (void*)::signal(signal_number, (void (*)(int))handler);
1960   }
1961 }
1962 
1963 void os::signal_raise(int signal_number) {
1964   raise(signal_number);
1965 }
1966 
1967 // The Win32 C runtime library maps all console control events other than ^C
1968 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
1969 // logoff, and shutdown events.  We therefore install our own console handler
1970 // that raises SIGTERM for the latter cases.
1971 //
1972 static BOOL WINAPI consoleHandler(DWORD event) {
1973   switch (event) {
1974   case CTRL_C_EVENT:
1975     if (VMError::is_error_reported()) {
1976       // Ctrl-C is pressed during error reporting, likely because the error
1977       // handler fails to abort. Let VM die immediately.
1978       os::die();
1979     }
1980 
1981     os::signal_raise(SIGINT);
1982     return TRUE;
1983     break;
1984   case CTRL_BREAK_EVENT:
1985     if (sigbreakHandler != NULL) {
1986       (*sigbreakHandler)(SIGBREAK);
1987     }
1988     return TRUE;
1989     break;
1990   case CTRL_LOGOFF_EVENT: {
1991     // Don't terminate JVM if it is running in a non-interactive session,
1992     // such as a service process.
1993     USEROBJECTFLAGS flags;
1994     HANDLE handle = GetProcessWindowStation();
1995     if (handle != NULL &&
1996         GetUserObjectInformation(handle, UOI_FLAGS, &flags,
1997         sizeof(USEROBJECTFLAGS), NULL)) {
1998       // If it is a non-interactive session, let next handler to deal
1999       // with it.
2000       if ((flags.dwFlags & WSF_VISIBLE) == 0) {
2001         return FALSE;
2002       }
2003     }
2004   }
2005   case CTRL_CLOSE_EVENT:
2006   case CTRL_SHUTDOWN_EVENT:
2007     os::signal_raise(SIGTERM);
2008     return TRUE;
2009     break;
2010   default:
2011     break;
2012   }
2013   return FALSE;
2014 }
2015 
2016 // The following code is moved from os.cpp for making this
2017 // code platform specific, which it is by its very nature.
2018 
2019 // Return maximum OS signal used + 1 for internal use only
2020 // Used as exit signal for signal_thread
2021 int os::sigexitnum_pd() {
2022   return NSIG;
2023 }
2024 
2025 // a counter for each possible signal value, including signal_thread exit signal
2026 static volatile jint pending_signals[NSIG+1] = { 0 };
2027 static Semaphore* sig_sem = NULL;
2028 
2029 static void jdk_misc_signal_init() {
2030   // Initialize signal structures
2031   memset((void*)pending_signals, 0, sizeof(pending_signals));
2032 
2033   // Initialize signal semaphore
2034   sig_sem = new Semaphore();
2035 
2036   // Programs embedding the VM do not want it to attempt to receive
2037   // events like CTRL_LOGOFF_EVENT, which are used to implement the
2038   // shutdown hooks mechanism introduced in 1.3.  For example, when
2039   // the VM is run as part of a Windows NT service (i.e., a servlet
2040   // engine in a web server), the correct behavior is for any console
2041   // control handler to return FALSE, not TRUE, because the OS's
2042   // "final" handler for such events allows the process to continue if
2043   // it is a service (while terminating it if it is not a service).
2044   // To make this behavior uniform and the mechanism simpler, we
2045   // completely disable the VM's usage of these console events if -Xrs
2046   // (=ReduceSignalUsage) is specified.  This means, for example, that
2047   // the CTRL-BREAK thread dump mechanism is also disabled in this
2048   // case.  See bugs 4323062, 4345157, and related bugs.
2049 
2050   // Add a CTRL-C handler
2051   SetConsoleCtrlHandler(consoleHandler, TRUE);
2052 }
2053 
2054 void os::signal_notify(int sig) {
2055   if (sig_sem != NULL) {
2056     Atomic::inc(&pending_signals[sig]);
2057     sig_sem->signal();
2058   } else {
2059     // Signal thread is not created with ReduceSignalUsage and jdk_misc_signal_init
2060     // initialization isn't called.
2061     assert(ReduceSignalUsage, "signal semaphore should be created");
2062   }
2063 }
2064 
2065 static int check_pending_signals() {
2066   while (true) {
2067     for (int i = 0; i < NSIG + 1; i++) {
2068       jint n = pending_signals[i];
2069       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2070         return i;
2071       }
2072     }
2073     JavaThread *thread = JavaThread::current();
2074 
2075     ThreadBlockInVM tbivm(thread);
2076 
2077     bool threadIsSuspended;
2078     do {
2079       thread->set_suspend_equivalent();
2080       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2081       sig_sem->wait();
2082 
2083       // were we externally suspended while we were waiting?
2084       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2085       if (threadIsSuspended) {
2086         // The semaphore has been incremented, but while we were waiting
2087         // another thread suspended us. We don't want to continue running
2088         // while suspended because that would surprise the thread that
2089         // suspended us.
2090         sig_sem->signal();
2091 
2092         thread->java_suspend_self();
2093       }
2094     } while (threadIsSuspended);
2095   }
2096 }
2097 
2098 int os::signal_wait() {
2099   return check_pending_signals();
2100 }
2101 
2102 // Implicit OS exception handling
2103 
2104 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo,
2105                       address handler) {
2106   JavaThread* thread = (JavaThread*) Thread::current_or_null();
2107   // Save pc in thread
2108 #ifdef _M_AMD64
2109   // Do not blow up if no thread info available.
2110   if (thread) {
2111     thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Rip);
2112   }
2113   // Set pc to handler
2114   exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
2115 #else
2116   // Do not blow up if no thread info available.
2117   if (thread) {
2118     thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Eip);
2119   }
2120   // Set pc to handler
2121   exceptionInfo->ContextRecord->Eip = (DWORD)(DWORD_PTR)handler;
2122 #endif
2123 
2124   // Continue the execution
2125   return EXCEPTION_CONTINUE_EXECUTION;
2126 }
2127 
2128 
2129 // Used for PostMortemDump
2130 extern "C" void safepoints();
2131 extern "C" void find(int x);
2132 extern "C" void events();
2133 
2134 // According to Windows API documentation, an illegal instruction sequence should generate
2135 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2136 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2137 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2138 
2139 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2140 
2141 // From "Execution Protection in the Windows Operating System" draft 0.35
2142 // Once a system header becomes available, the "real" define should be
2143 // included or copied here.
2144 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2145 
2146 // Windows Vista/2008 heap corruption check
2147 #define EXCEPTION_HEAP_CORRUPTION        0xC0000374
2148 
2149 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2150 // C++ compiler contain this error code. Because this is a compiler-generated
2151 // error, the code is not listed in the Win32 API header files.
2152 // The code is actually a cryptic mnemonic device, with the initial "E"
2153 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2154 // ASCII values of "msc".
2155 
2156 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION    0xE06D7363
2157 
2158 #define def_excpt(val) { #val, (val) }
2159 
2160 static const struct { char* name; uint number; } exceptlabels[] = {
2161     def_excpt(EXCEPTION_ACCESS_VIOLATION),
2162     def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2163     def_excpt(EXCEPTION_BREAKPOINT),
2164     def_excpt(EXCEPTION_SINGLE_STEP),
2165     def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2166     def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2167     def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2168     def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2169     def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2170     def_excpt(EXCEPTION_FLT_OVERFLOW),
2171     def_excpt(EXCEPTION_FLT_STACK_CHECK),
2172     def_excpt(EXCEPTION_FLT_UNDERFLOW),
2173     def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2174     def_excpt(EXCEPTION_INT_OVERFLOW),
2175     def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2176     def_excpt(EXCEPTION_IN_PAGE_ERROR),
2177     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2178     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2179     def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2180     def_excpt(EXCEPTION_STACK_OVERFLOW),
2181     def_excpt(EXCEPTION_INVALID_DISPOSITION),
2182     def_excpt(EXCEPTION_GUARD_PAGE),
2183     def_excpt(EXCEPTION_INVALID_HANDLE),
2184     def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2185     def_excpt(EXCEPTION_HEAP_CORRUPTION)
2186 };
2187 
2188 #undef def_excpt
2189 
2190 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2191   uint code = static_cast<uint>(exception_code);
2192   for (uint i = 0; i < ARRAY_SIZE(exceptlabels); ++i) {
2193     if (exceptlabels[i].number == code) {
2194       jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2195       return buf;
2196     }
2197   }
2198 
2199   return NULL;
2200 }
2201 
2202 //-----------------------------------------------------------------------------
2203 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2204   // handle exception caused by idiv; should only happen for -MinInt/-1
2205   // (division by zero is handled explicitly)
2206 #ifdef  _M_AMD64
2207   PCONTEXT ctx = exceptionInfo->ContextRecord;
2208   address pc = (address)ctx->Rip;
2209   assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && pc[1] == 0xF7 || pc[0] == 0xF7, "not an idiv opcode");
2210   assert(pc[0] >= Assembler::REX && pc[0] <= Assembler::REX_WRXB && (pc[2] & ~0x7) == 0xF8 || (pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2211   if (pc[0] == 0xF7) {
2212     // set correct result values and continue after idiv instruction
2213     ctx->Rip = (DWORD64)pc + 2;        // idiv reg, reg  is 2 bytes
2214   } else {
2215     ctx->Rip = (DWORD64)pc + 3;        // REX idiv reg, reg  is 3 bytes
2216   }
2217   // Do not set ctx->Rax as it already contains the correct value (either 32 or 64 bit, depending on the operation)
2218   // this is the case because the exception only happens for -MinValue/-1 and -MinValue is always in rax because of the
2219   // idiv opcode (0xF7).
2220   ctx->Rdx = (DWORD)0;             // remainder
2221   // Continue the execution
2222 #else
2223   PCONTEXT ctx = exceptionInfo->ContextRecord;
2224   address pc = (address)ctx->Eip;
2225   assert(pc[0] == 0xF7, "not an idiv opcode");
2226   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2227   assert(ctx->Eax == min_jint, "unexpected idiv exception");
2228   // set correct result values and continue after idiv instruction
2229   ctx->Eip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2230   ctx->Eax = (DWORD)min_jint;      // result
2231   ctx->Edx = (DWORD)0;             // remainder
2232   // Continue the execution
2233 #endif
2234   return EXCEPTION_CONTINUE_EXECUTION;
2235 }
2236 
2237 //-----------------------------------------------------------------------------
2238 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2239   PCONTEXT ctx = exceptionInfo->ContextRecord;
2240 #ifndef  _WIN64
2241   // handle exception caused by native method modifying control word
2242   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2243 
2244   switch (exception_code) {
2245   case EXCEPTION_FLT_DENORMAL_OPERAND:
2246   case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2247   case EXCEPTION_FLT_INEXACT_RESULT:
2248   case EXCEPTION_FLT_INVALID_OPERATION:
2249   case EXCEPTION_FLT_OVERFLOW:
2250   case EXCEPTION_FLT_STACK_CHECK:
2251   case EXCEPTION_FLT_UNDERFLOW:
2252     jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2253     if (fp_control_word != ctx->FloatSave.ControlWord) {
2254       // Restore FPCW and mask out FLT exceptions
2255       ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2256       // Mask out pending FLT exceptions
2257       ctx->FloatSave.StatusWord &=  0xffffff00;
2258       return EXCEPTION_CONTINUE_EXECUTION;
2259     }
2260   }
2261 
2262   if (prev_uef_handler != NULL) {
2263     // We didn't handle this exception so pass it to the previous
2264     // UnhandledExceptionFilter.
2265     return (prev_uef_handler)(exceptionInfo);
2266   }
2267 #else // !_WIN64
2268   // On Windows, the mxcsr control bits are non-volatile across calls
2269   // See also CR 6192333
2270   //
2271   jint MxCsr = INITIAL_MXCSR;
2272   // we can't use StubRoutines::addr_mxcsr_std()
2273   // because in Win64 mxcsr is not saved there
2274   if (MxCsr != ctx->MxCsr) {
2275     ctx->MxCsr = MxCsr;
2276     return EXCEPTION_CONTINUE_EXECUTION;
2277   }
2278 #endif // !_WIN64
2279 
2280   return EXCEPTION_CONTINUE_SEARCH;
2281 }
2282 
2283 static inline void report_error(Thread* t, DWORD exception_code,
2284                                 address addr, void* siginfo, void* context) {
2285   VMError::report_and_die(t, exception_code, addr, siginfo, context);
2286 
2287   // If UseOsErrorReporting, this will return here and save the error file
2288   // somewhere where we can find it in the minidump.
2289 }
2290 
2291 bool os::win32::get_frame_at_stack_banging_point(JavaThread* thread,
2292         struct _EXCEPTION_POINTERS* exceptionInfo, address pc, frame* fr) {
2293   PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2294   address addr = (address) exceptionRecord->ExceptionInformation[1];
2295   if (Interpreter::contains(pc)) {
2296     *fr = os::fetch_frame_from_context((void*)exceptionInfo->ContextRecord);
2297     if (!fr->is_first_java_frame()) {
2298       // get_frame_at_stack_banging_point() is only called when we
2299       // have well defined stacks so java_sender() calls do not need
2300       // to assert safe_for_sender() first.
2301       *fr = fr->java_sender();
2302     }
2303   } else {
2304     // more complex code with compiled code
2305     assert(!Interpreter::contains(pc), "Interpreted methods should have been handled above");
2306     CodeBlob* cb = CodeCache::find_blob(pc);
2307     if (cb == NULL || !cb->is_nmethod() || cb->is_frame_complete_at(pc)) {
2308       // Not sure where the pc points to, fallback to default
2309       // stack overflow handling
2310       return false;
2311     } else {
2312       *fr = os::fetch_frame_from_context((void*)exceptionInfo->ContextRecord);
2313       // in compiled code, the stack banging is performed just after the return pc
2314       // has been pushed on the stack
2315       *fr = frame(fr->sp() + 1, fr->fp(), (address)*(fr->sp()));
2316       if (!fr->is_java_frame()) {
2317         // See java_sender() comment above.
2318         *fr = fr->java_sender();
2319       }
2320     }
2321   }
2322   assert(fr->is_java_frame(), "Safety check");
2323   return true;
2324 }
2325 
2326 //-----------------------------------------------------------------------------
2327 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2328   if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2329   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2330 #ifdef _M_AMD64
2331   address pc = (address) exceptionInfo->ContextRecord->Rip;
2332 #else
2333   address pc = (address) exceptionInfo->ContextRecord->Eip;
2334 #endif
2335   Thread* t = Thread::current_or_null_safe();
2336 
2337   // Handle SafeFetch32 and SafeFetchN exceptions.
2338   if (StubRoutines::is_safefetch_fault(pc)) {
2339     return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc));
2340   }
2341 
2342 #ifndef _WIN64
2343   // Execution protection violation - win32 running on AMD64 only
2344   // Handled first to avoid misdiagnosis as a "normal" access violation;
2345   // This is safe to do because we have a new/unique ExceptionInformation
2346   // code for this condition.
2347   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2348     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2349     int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2350     address addr = (address) exceptionRecord->ExceptionInformation[1];
2351 
2352     if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2353       int page_size = os::vm_page_size();
2354 
2355       // Make sure the pc and the faulting address are sane.
2356       //
2357       // If an instruction spans a page boundary, and the page containing
2358       // the beginning of the instruction is executable but the following
2359       // page is not, the pc and the faulting address might be slightly
2360       // different - we still want to unguard the 2nd page in this case.
2361       //
2362       // 15 bytes seems to be a (very) safe value for max instruction size.
2363       bool pc_is_near_addr =
2364         (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2365       bool instr_spans_page_boundary =
2366         (align_down((intptr_t) pc ^ (intptr_t) addr,
2367                          (intptr_t) page_size) > 0);
2368 
2369       if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2370         static volatile address last_addr =
2371           (address) os::non_memory_address_word();
2372 
2373         // In conservative mode, don't unguard unless the address is in the VM
2374         if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2375             (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2376 
2377           // Set memory to RWX and retry
2378           address page_start = align_down(addr, page_size);
2379           bool res = os::protect_memory((char*) page_start, page_size,
2380                                         os::MEM_PROT_RWX);
2381 
2382           log_debug(os)("Execution protection violation "
2383                         "at " INTPTR_FORMAT
2384                         ", unguarding " INTPTR_FORMAT ": %s", p2i(addr),
2385                         p2i(page_start), (res ? "success" : os::strerror(errno)));
2386 
2387           // Set last_addr so if we fault again at the same address, we don't
2388           // end up in an endless loop.
2389           //
2390           // There are two potential complications here.  Two threads trapping
2391           // at the same address at the same time could cause one of the
2392           // threads to think it already unguarded, and abort the VM.  Likely
2393           // very rare.
2394           //
2395           // The other race involves two threads alternately trapping at
2396           // different addresses and failing to unguard the page, resulting in
2397           // an endless loop.  This condition is probably even more unlikely
2398           // than the first.
2399           //
2400           // Although both cases could be avoided by using locks or thread
2401           // local last_addr, these solutions are unnecessary complication:
2402           // this handler is a best-effort safety net, not a complete solution.
2403           // It is disabled by default and should only be used as a workaround
2404           // in case we missed any no-execute-unsafe VM code.
2405 
2406           last_addr = addr;
2407 
2408           return EXCEPTION_CONTINUE_EXECUTION;
2409         }
2410       }
2411 
2412       // Last unguard failed or not unguarding
2413       tty->print_raw_cr("Execution protection violation");
2414       report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2415                    exceptionInfo->ContextRecord);
2416       return EXCEPTION_CONTINUE_SEARCH;
2417     }
2418   }
2419 #endif // _WIN64
2420 
2421   // Check to see if we caught the safepoint code in the
2422   // process of write protecting the memory serialization page.
2423   // It write enables the page immediately after protecting it
2424   // so just return.
2425   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2426     if (t != NULL && t->is_Java_thread()) {
2427       JavaThread* thread = (JavaThread*) t;
2428       PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2429       address addr = (address) exceptionRecord->ExceptionInformation[1];
2430       if (os::is_memory_serialize_page(thread, addr)) {
2431         // Block current thread until the memory serialize page permission restored.
2432         os::block_on_serialize_page_trap();
2433         return EXCEPTION_CONTINUE_EXECUTION;
2434       }
2435     }
2436   }
2437 
2438   if ((exception_code == EXCEPTION_ACCESS_VIOLATION) &&
2439       VM_Version::is_cpuinfo_segv_addr(pc)) {
2440     // Verify that OS save/restore AVX registers.
2441     return Handle_Exception(exceptionInfo, VM_Version::cpuinfo_cont_addr());
2442   }
2443 
2444   if (t != NULL && t->is_Java_thread()) {
2445     JavaThread* thread = (JavaThread*) t;
2446     bool in_java = thread->thread_state() == _thread_in_Java;
2447 
2448     // Handle potential stack overflows up front.
2449     if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2450       if (thread->stack_guards_enabled()) {
2451         if (in_java) {
2452           frame fr;
2453           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2454           address addr = (address) exceptionRecord->ExceptionInformation[1];
2455           if (os::win32::get_frame_at_stack_banging_point(thread, exceptionInfo, pc, &fr)) {
2456             assert(fr.is_java_frame(), "Must be a Java frame");
2457             SharedRuntime::look_for_reserved_stack_annotated_method(thread, fr);
2458           }
2459         }
2460         // Yellow zone violation.  The o/s has unprotected the first yellow
2461         // zone page for us.  Note:  must call disable_stack_yellow_zone to
2462         // update the enabled status, even if the zone contains only one page.
2463         assert(thread->thread_state() != _thread_in_vm, "Undersized StackShadowPages");
2464         thread->disable_stack_yellow_reserved_zone();
2465         // If not in java code, return and hope for the best.
2466         return in_java
2467             ? Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2468             :  EXCEPTION_CONTINUE_EXECUTION;
2469       } else {
2470         // Fatal red zone violation.
2471         thread->disable_stack_red_zone();
2472         tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2473         report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2474                       exceptionInfo->ContextRecord);
2475         return EXCEPTION_CONTINUE_SEARCH;
2476       }
2477     } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2478       // Either stack overflow or null pointer exception.
2479       if (in_java) {
2480         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2481         address addr = (address) exceptionRecord->ExceptionInformation[1];
2482         address stack_end = thread->stack_end();
2483         if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2484           // Stack overflow.
2485           assert(!os::uses_stack_guard_pages(),
2486                  "should be caught by red zone code above.");
2487           return Handle_Exception(exceptionInfo,
2488                                   SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2489         }
2490         // Check for safepoint polling and implicit null
2491         // We only expect null pointers in the stubs (vtable)
2492         // the rest are checked explicitly now.
2493         CodeBlob* cb = CodeCache::find_blob(pc);
2494         if (cb != NULL) {
2495           if (os::is_poll_address(addr)) {
2496             address stub = SharedRuntime::get_poll_stub(pc);
2497             return Handle_Exception(exceptionInfo, stub);
2498           }
2499         }
2500         {
2501 #ifdef _WIN64
2502           // If it's a legal stack address map the entire region in
2503           //
2504           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2505           address addr = (address) exceptionRecord->ExceptionInformation[1];
2506           if (addr > thread->stack_reserved_zone_base() && addr < thread->stack_base()) {
2507             addr = (address)((uintptr_t)addr &
2508                              (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2509             os::commit_memory((char *)addr, thread->stack_base() - addr,
2510                               !ExecMem);
2511             return EXCEPTION_CONTINUE_EXECUTION;
2512           } else
2513 #endif
2514           {
2515             // Null pointer exception.
2516             if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr)) {
2517               address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2518               if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2519             }
2520             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2521                          exceptionInfo->ContextRecord);
2522             return EXCEPTION_CONTINUE_SEARCH;
2523           }
2524         }
2525       }
2526 
2527 #ifdef _WIN64
2528       // Special care for fast JNI field accessors.
2529       // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2530       // in and the heap gets shrunk before the field access.
2531       if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2532         address addr = JNI_FastGetField::find_slowcase_pc(pc);
2533         if (addr != (address)-1) {
2534           return Handle_Exception(exceptionInfo, addr);
2535         }
2536       }
2537 #endif
2538 
2539       // Stack overflow or null pointer exception in native code.
2540       report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2541                    exceptionInfo->ContextRecord);
2542       return EXCEPTION_CONTINUE_SEARCH;
2543     } // /EXCEPTION_ACCESS_VIOLATION
2544     // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
2545 
2546     if (exception_code == EXCEPTION_IN_PAGE_ERROR) {
2547       CompiledMethod* nm = NULL;
2548       JavaThread* thread = (JavaThread*)t;
2549       if (in_java) {
2550         CodeBlob* cb = CodeCache::find_blob_unsafe(pc);
2551         nm = (cb != NULL) ? cb->as_compiled_method_or_null() : NULL;
2552       }
2553       if ((thread->thread_state() == _thread_in_vm &&
2554           thread->doing_unsafe_access()) ||
2555           (nm != NULL && nm->has_unsafe_access())) {
2556         return Handle_Exception(exceptionInfo, SharedRuntime::handle_unsafe_access(thread, (address)Assembler::locate_next_instruction(pc)));
2557       }
2558     }
2559 
2560     if (in_java) {
2561       switch (exception_code) {
2562       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2563         return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2564 
2565       case EXCEPTION_INT_OVERFLOW:
2566         return Handle_IDiv_Exception(exceptionInfo);
2567 
2568       } // switch
2569     }
2570     if (((thread->thread_state() == _thread_in_Java) ||
2571          (thread->thread_state() == _thread_in_native)) &&
2572          exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION) {
2573       LONG result=Handle_FLT_Exception(exceptionInfo);
2574       if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2575     }
2576   }
2577 
2578   if (exception_code != EXCEPTION_BREAKPOINT) {
2579     report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2580                  exceptionInfo->ContextRecord);
2581   }
2582   return EXCEPTION_CONTINUE_SEARCH;
2583 }
2584 
2585 #ifndef _WIN64
2586 // Special care for fast JNI accessors.
2587 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2588 // the heap gets shrunk before the field access.
2589 // Need to install our own structured exception handler since native code may
2590 // install its own.
2591 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2592   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2593   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2594     address pc = (address) exceptionInfo->ContextRecord->Eip;
2595     address addr = JNI_FastGetField::find_slowcase_pc(pc);
2596     if (addr != (address)-1) {
2597       return Handle_Exception(exceptionInfo, addr);
2598     }
2599   }
2600   return EXCEPTION_CONTINUE_SEARCH;
2601 }
2602 
2603 #define DEFINE_FAST_GETFIELD(Return, Fieldname, Result)                     \
2604   Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env,           \
2605                                                      jobject obj,           \
2606                                                      jfieldID fieldID) {    \
2607     __try {                                                                 \
2608       return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env,       \
2609                                                                  obj,       \
2610                                                                  fieldID);  \
2611     } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)        \
2612                                               _exception_info())) {         \
2613     }                                                                       \
2614     return 0;                                                               \
2615   }
2616 
2617 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2618 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2619 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2620 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2621 DEFINE_FAST_GETFIELD(jint,     int,    Int)
2622 DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2623 DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2624 DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2625 
2626 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2627   switch (type) {
2628   case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2629   case T_BYTE:    return (address)jni_fast_GetByteField_wrapper;
2630   case T_CHAR:    return (address)jni_fast_GetCharField_wrapper;
2631   case T_SHORT:   return (address)jni_fast_GetShortField_wrapper;
2632   case T_INT:     return (address)jni_fast_GetIntField_wrapper;
2633   case T_LONG:    return (address)jni_fast_GetLongField_wrapper;
2634   case T_FLOAT:   return (address)jni_fast_GetFloatField_wrapper;
2635   case T_DOUBLE:  return (address)jni_fast_GetDoubleField_wrapper;
2636   default:        ShouldNotReachHere();
2637   }
2638   return (address)-1;
2639 }
2640 #endif
2641 
2642 // Virtual Memory
2643 
2644 int os::vm_page_size() { return os::win32::vm_page_size(); }
2645 int os::vm_allocation_granularity() {
2646   return os::win32::vm_allocation_granularity();
2647 }
2648 
2649 // Windows large page support is available on Windows 2003. In order to use
2650 // large page memory, the administrator must first assign additional privilege
2651 // to the user:
2652 //   + select Control Panel -> Administrative Tools -> Local Security Policy
2653 //   + select Local Policies -> User Rights Assignment
2654 //   + double click "Lock pages in memory", add users and/or groups
2655 //   + reboot
2656 // Note the above steps are needed for administrator as well, as administrators
2657 // by default do not have the privilege to lock pages in memory.
2658 //
2659 // Note about Windows 2003: although the API supports committing large page
2660 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2661 // scenario, I found through experiment it only uses large page if the entire
2662 // memory region is reserved and committed in a single VirtualAlloc() call.
2663 // This makes Windows large page support more or less like Solaris ISM, in
2664 // that the entire heap must be committed upfront. This probably will change
2665 // in the future, if so the code below needs to be revisited.
2666 
2667 #ifndef MEM_LARGE_PAGES
2668   #define MEM_LARGE_PAGES 0x20000000
2669 #endif
2670 
2671 static HANDLE    _hProcess;
2672 static HANDLE    _hToken;
2673 
2674 // Container for NUMA node list info
2675 class NUMANodeListHolder {
2676  private:
2677   int *_numa_used_node_list;  // allocated below
2678   int _numa_used_node_count;
2679 
2680   void free_node_list() {
2681     if (_numa_used_node_list != NULL) {
2682       FREE_C_HEAP_ARRAY(int, _numa_used_node_list);
2683     }
2684   }
2685 
2686  public:
2687   NUMANodeListHolder() {
2688     _numa_used_node_count = 0;
2689     _numa_used_node_list = NULL;
2690     // do rest of initialization in build routine (after function pointers are set up)
2691   }
2692 
2693   ~NUMANodeListHolder() {
2694     free_node_list();
2695   }
2696 
2697   bool build() {
2698     DWORD_PTR proc_aff_mask;
2699     DWORD_PTR sys_aff_mask;
2700     if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2701     ULONG highest_node_number;
2702     if (!GetNumaHighestNodeNumber(&highest_node_number)) return false;
2703     free_node_list();
2704     _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal);
2705     for (unsigned int i = 0; i <= highest_node_number; i++) {
2706       ULONGLONG proc_mask_numa_node;
2707       if (!GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2708       if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2709         _numa_used_node_list[_numa_used_node_count++] = i;
2710       }
2711     }
2712     return (_numa_used_node_count > 1);
2713   }
2714 
2715   int get_count() { return _numa_used_node_count; }
2716   int get_node_list_entry(int n) {
2717     // for indexes out of range, returns -1
2718     return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2719   }
2720 
2721 } numa_node_list_holder;
2722 
2723 
2724 
2725 static size_t _large_page_size = 0;
2726 
2727 static bool request_lock_memory_privilege() {
2728   _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2729                           os::current_process_id());
2730 
2731   LUID luid;
2732   if (_hProcess != NULL &&
2733       OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2734       LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2735 
2736     TOKEN_PRIVILEGES tp;
2737     tp.PrivilegeCount = 1;
2738     tp.Privileges[0].Luid = luid;
2739     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2740 
2741     // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2742     // privilege. Check GetLastError() too. See MSDN document.
2743     if (AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2744         (GetLastError() == ERROR_SUCCESS)) {
2745       return true;
2746     }
2747   }
2748 
2749   return false;
2750 }
2751 
2752 static void cleanup_after_large_page_init() {
2753   if (_hProcess) CloseHandle(_hProcess);
2754   _hProcess = NULL;
2755   if (_hToken) CloseHandle(_hToken);
2756   _hToken = NULL;
2757 }
2758 
2759 static bool numa_interleaving_init() {
2760   bool success = false;
2761   bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2762 
2763   // print a warning if UseNUMAInterleaving flag is specified on command line
2764   bool warn_on_failure = use_numa_interleaving_specified;
2765 #define WARN(msg) if (warn_on_failure) { warning(msg); }
2766 
2767   // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
2768   size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2769   NUMAInterleaveGranularity = align_up(NUMAInterleaveGranularity, min_interleave_granularity);
2770 
2771   if (numa_node_list_holder.build()) {
2772     if (log_is_enabled(Debug, os, cpu)) {
2773       Log(os, cpu) log;
2774       log.debug("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
2775       for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
2776         log.debug("  %d ", numa_node_list_holder.get_node_list_entry(i));
2777       }
2778     }
2779     success = true;
2780   } else {
2781     WARN("Process does not cover multiple NUMA nodes.");
2782   }
2783   if (!success) {
2784     if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
2785   }
2786   return success;
2787 #undef WARN
2788 }
2789 
2790 // this routine is used whenever we need to reserve a contiguous VA range
2791 // but we need to make separate VirtualAlloc calls for each piece of the range
2792 // Reasons for doing this:
2793 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
2794 //  * UseNUMAInterleaving requires a separate node for each piece
2795 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags,
2796                                          DWORD prot,
2797                                          bool should_inject_error = false) {
2798   char * p_buf;
2799   // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
2800   size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
2801   size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
2802 
2803   // first reserve enough address space in advance since we want to be
2804   // able to break a single contiguous virtual address range into multiple
2805   // large page commits but WS2003 does not allow reserving large page space
2806   // so we just use 4K pages for reserve, this gives us a legal contiguous
2807   // address space. then we will deallocate that reservation, and re alloc
2808   // using large pages
2809   const size_t size_of_reserve = bytes + chunk_size;
2810   if (bytes > size_of_reserve) {
2811     // Overflowed.
2812     return NULL;
2813   }
2814   p_buf = (char *) VirtualAlloc(addr,
2815                                 size_of_reserve,  // size of Reserve
2816                                 MEM_RESERVE,
2817                                 PAGE_READWRITE);
2818   // If reservation failed, return NULL
2819   if (p_buf == NULL) return NULL;
2820   MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
2821   os::release_memory(p_buf, bytes + chunk_size);
2822 
2823   // we still need to round up to a page boundary (in case we are using large pages)
2824   // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
2825   // instead we handle this in the bytes_to_rq computation below
2826   p_buf = align_up(p_buf, page_size);
2827 
2828   // now go through and allocate one chunk at a time until all bytes are
2829   // allocated
2830   size_t  bytes_remaining = bytes;
2831   // An overflow of align_up() would have been caught above
2832   // in the calculation of size_of_reserve.
2833   char * next_alloc_addr = p_buf;
2834   HANDLE hProc = GetCurrentProcess();
2835 
2836 #ifdef ASSERT
2837   // Variable for the failure injection
2838   int ran_num = os::random();
2839   size_t fail_after = ran_num % bytes;
2840 #endif
2841 
2842   int count=0;
2843   while (bytes_remaining) {
2844     // select bytes_to_rq to get to the next chunk_size boundary
2845 
2846     size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
2847     // Note allocate and commit
2848     char * p_new;
2849 
2850 #ifdef ASSERT
2851     bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
2852 #else
2853     const bool inject_error_now = false;
2854 #endif
2855 
2856     if (inject_error_now) {
2857       p_new = NULL;
2858     } else {
2859       if (!UseNUMAInterleaving) {
2860         p_new = (char *) VirtualAlloc(next_alloc_addr,
2861                                       bytes_to_rq,
2862                                       flags,
2863                                       prot);
2864       } else {
2865         // get the next node to use from the used_node_list
2866         assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
2867         DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
2868         p_new = (char *)VirtualAllocExNuma(hProc, next_alloc_addr, bytes_to_rq, flags, prot, node);
2869       }
2870     }
2871 
2872     if (p_new == NULL) {
2873       // Free any allocated pages
2874       if (next_alloc_addr > p_buf) {
2875         // Some memory was committed so release it.
2876         size_t bytes_to_release = bytes - bytes_remaining;
2877         // NMT has yet to record any individual blocks, so it
2878         // need to create a dummy 'reserve' record to match
2879         // the release.
2880         MemTracker::record_virtual_memory_reserve((address)p_buf,
2881                                                   bytes_to_release, CALLER_PC);
2882         os::release_memory(p_buf, bytes_to_release);
2883       }
2884 #ifdef ASSERT
2885       if (should_inject_error) {
2886         log_develop_debug(pagesize)("Reserving pages individually failed.");
2887       }
2888 #endif
2889       return NULL;
2890     }
2891 
2892     bytes_remaining -= bytes_to_rq;
2893     next_alloc_addr += bytes_to_rq;
2894     count++;
2895   }
2896   // Although the memory is allocated individually, it is returned as one.
2897   // NMT records it as one block.
2898   if ((flags & MEM_COMMIT) != 0) {
2899     MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC);
2900   } else {
2901     MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC);
2902   }
2903 
2904   // made it this far, success
2905   return p_buf;
2906 }
2907 
2908 
2909 
2910 void os::large_page_init() {
2911   if (!UseLargePages) return;
2912 
2913   // print a warning if any large page related flag is specified on command line
2914   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
2915                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
2916   bool success = false;
2917 
2918 #define WARN(msg) if (warn_on_failure) { warning(msg); }
2919   if (request_lock_memory_privilege()) {
2920     size_t s = GetLargePageMinimum();
2921     if (s) {
2922 #if defined(IA32) || defined(AMD64)
2923       if (s > 4*M || LargePageSizeInBytes > 4*M) {
2924         WARN("JVM cannot use large pages bigger than 4mb.");
2925       } else {
2926 #endif
2927         if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
2928           _large_page_size = LargePageSizeInBytes;
2929         } else {
2930           _large_page_size = s;
2931         }
2932         success = true;
2933 #if defined(IA32) || defined(AMD64)
2934       }
2935 #endif
2936     } else {
2937       WARN("Large page is not supported by the processor.");
2938     }
2939   } else {
2940     WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
2941   }
2942 #undef WARN
2943 
2944   const size_t default_page_size = (size_t) vm_page_size();
2945   if (success && _large_page_size > default_page_size) {
2946     _page_sizes[0] = _large_page_size;
2947     _page_sizes[1] = default_page_size;
2948     _page_sizes[2] = 0;
2949   }
2950 
2951   cleanup_after_large_page_init();
2952   UseLargePages = success;
2953 }
2954 
2955 int os::create_file_for_heap(const char* dir) {
2956 
2957   const char name_template[] = "/jvmheap.XXXXXX";
2958   char *fullname = (char*)os::malloc((strlen(dir) + strlen(name_template) + 1), mtInternal);
2959   if (fullname == NULL) {
2960     vm_exit_during_initialization(err_msg("Malloc failed during creation of backing file for heap (%s)", os::strerror(errno)));
2961     return -1;
2962   }
2963 
2964   (void)strncpy(fullname, dir, strlen(dir)+1);
2965   (void)strncat(fullname, name_template, strlen(name_template));
2966 
2967   os::native_path(fullname);
2968 
2969   char *path = _mktemp(fullname);
2970   if (path == NULL) {
2971     warning("_mktemp could not create file name from template %s (%s)", fullname, os::strerror(errno));
2972     os::free(fullname);
2973     return -1;
2974   }
2975 
2976   int fd = _open(path, O_RDWR | O_CREAT | O_TEMPORARY | O_EXCL, S_IWRITE | S_IREAD);
2977 
2978   os::free(fullname);
2979   if (fd < 0) {
2980     warning("Problem opening file for heap (%s)", os::strerror(errno));
2981     return -1;
2982   }
2983   return fd;
2984 }
2985 
2986 // If 'base' is not NULL, function will return NULL if it cannot get 'base'
2987 char* os::map_memory_to_file(char* base, size_t size, int fd) {
2988   assert(fd != -1, "File descriptor is not valid");
2989 
2990   HANDLE fh = (HANDLE)_get_osfhandle(fd);
2991 #ifdef _LP64
2992   HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE,
2993     (DWORD)(size >> 32), (DWORD)(size & 0xFFFFFFFF), NULL);
2994 #else
2995   HANDLE fileMapping = CreateFileMapping(fh, NULL, PAGE_READWRITE,
2996     0, (DWORD)size, NULL);
2997 #endif
2998   if (fileMapping == NULL) {
2999     if (GetLastError() == ERROR_DISK_FULL) {
3000       vm_exit_during_initialization(err_msg("Could not allocate sufficient disk space for Java heap"));
3001     }
3002     else {
3003       vm_exit_during_initialization(err_msg("Error in mapping Java heap at the given filesystem directory"));
3004     }
3005 
3006     return NULL;
3007   }
3008 
3009   LPVOID addr = MapViewOfFileEx(fileMapping, FILE_MAP_WRITE, 0, 0, size, base);
3010 
3011   CloseHandle(fileMapping);
3012 
3013   return (char*)addr;
3014 }
3015 
3016 char* os::replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd) {
3017   assert(fd != -1, "File descriptor is not valid");
3018   assert(base != NULL, "Base address cannot be NULL");
3019 
3020   release_memory(base, size);
3021   return map_memory_to_file(base, size, fd);
3022 }
3023 
3024 // On win32, one cannot release just a part of reserved memory, it's an
3025 // all or nothing deal.  When we split a reservation, we must break the
3026 // reservation into two reservations.
3027 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
3028                                   bool realloc) {
3029   if (size > 0) {
3030     release_memory(base, size);
3031     if (realloc) {
3032       reserve_memory(split, base);
3033     }
3034     if (size != split) {
3035       reserve_memory(size - split, base + split);
3036     }
3037   }
3038 }
3039 
3040 // Multiple threads can race in this code but it's not possible to unmap small sections of
3041 // virtual space to get requested alignment, like posix-like os's.
3042 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
3043 char* os::reserve_memory_aligned(size_t size, size_t alignment, int file_desc) {
3044   assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,
3045          "Alignment must be a multiple of allocation granularity (page size)");
3046   assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");
3047 
3048   size_t extra_size = size + alignment;
3049   assert(extra_size >= size, "overflow, size is too large to allow alignment");
3050 
3051   char* aligned_base = NULL;
3052 
3053   do {
3054     char* extra_base = os::reserve_memory(extra_size, NULL, alignment, file_desc);
3055     if (extra_base == NULL) {
3056       return NULL;
3057     }
3058     // Do manual alignment
3059     aligned_base = align_up(extra_base, alignment);
3060 
3061     if (file_desc != -1) {
3062       os::unmap_memory(extra_base, extra_size);
3063     } else {
3064       os::release_memory(extra_base, extra_size);
3065     }
3066 
3067     aligned_base = os::reserve_memory(size, aligned_base, 0, file_desc);
3068 
3069   } while (aligned_base == NULL);
3070 
3071   return aligned_base;
3072 }
3073 
3074 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
3075   assert((size_t)addr % os::vm_allocation_granularity() == 0,
3076          "reserve alignment");
3077   assert(bytes % os::vm_page_size() == 0, "reserve page size");
3078   char* res;
3079   // note that if UseLargePages is on, all the areas that require interleaving
3080   // will go thru reserve_memory_special rather than thru here.
3081   bool use_individual = (UseNUMAInterleaving && !UseLargePages);
3082   if (!use_individual) {
3083     res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
3084   } else {
3085     elapsedTimer reserveTimer;
3086     if (Verbose && PrintMiscellaneous) reserveTimer.start();
3087     // in numa interleaving, we have to allocate pages individually
3088     // (well really chunks of NUMAInterleaveGranularity size)
3089     res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
3090     if (res == NULL) {
3091       warning("NUMA page allocation failed");
3092     }
3093     if (Verbose && PrintMiscellaneous) {
3094       reserveTimer.stop();
3095       tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3096                     reserveTimer.milliseconds(), reserveTimer.ticks());
3097     }
3098   }
3099   assert(res == NULL || addr == NULL || addr == res,
3100          "Unexpected address from reserve.");
3101 
3102   return res;
3103 }
3104 
3105 // Reserve memory at an arbitrary address, only if that area is
3106 // available (and not reserved for something else).
3107 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3108   // Windows os::reserve_memory() fails of the requested address range is
3109   // not avilable.
3110   return reserve_memory(bytes, requested_addr);
3111 }
3112 
3113 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr, int file_desc) {
3114   assert(file_desc >= 0, "file_desc is not valid");
3115   return map_memory_to_file(requested_addr, bytes, file_desc);
3116 }
3117 
3118 size_t os::large_page_size() {
3119   return _large_page_size;
3120 }
3121 
3122 bool os::can_commit_large_page_memory() {
3123   // Windows only uses large page memory when the entire region is reserved
3124   // and committed in a single VirtualAlloc() call. This may change in the
3125   // future, but with Windows 2003 it's not possible to commit on demand.
3126   return false;
3127 }
3128 
3129 bool os::can_execute_large_page_memory() {
3130   return true;
3131 }
3132 
3133 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr,
3134                                  bool exec) {
3135   assert(UseLargePages, "only for large pages");
3136 
3137   if (!is_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3138     return NULL; // Fallback to small pages.
3139   }
3140 
3141   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3142   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3143 
3144   // with large pages, there are two cases where we need to use Individual Allocation
3145   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3146   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3147   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3148     log_debug(pagesize)("Reserving large pages individually.");
3149 
3150     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3151     if (p_buf == NULL) {
3152       // give an appropriate warning message
3153       if (UseNUMAInterleaving) {
3154         warning("NUMA large page allocation failed, UseLargePages flag ignored");
3155       }
3156       if (UseLargePagesIndividualAllocation) {
3157         warning("Individually allocated large pages failed, "
3158                 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3159       }
3160       return NULL;
3161     }
3162 
3163     return p_buf;
3164 
3165   } else {
3166     log_debug(pagesize)("Reserving large pages in a single large chunk.");
3167 
3168     // normal policy just allocate it all at once
3169     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3170     char * res = (char *)VirtualAlloc(addr, bytes, flag, prot);
3171     if (res != NULL) {
3172       MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, CALLER_PC);
3173     }
3174 
3175     return res;
3176   }
3177 }
3178 
3179 bool os::release_memory_special(char* base, size_t bytes) {
3180   assert(base != NULL, "Sanity check");
3181   return release_memory(base, bytes);
3182 }
3183 
3184 void os::print_statistics() {
3185 }
3186 
3187 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
3188   int err = os::get_last_error();
3189   char buf[256];
3190   size_t buf_len = os::lasterror(buf, sizeof(buf));
3191   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
3192           ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
3193           exec, buf_len != 0 ? buf : "<no_error_string>", err);
3194 }
3195 
3196 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
3197   if (bytes == 0) {
3198     // Don't bother the OS with noops.
3199     return true;
3200   }
3201   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3202   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3203   // Don't attempt to print anything if the OS call fails. We're
3204   // probably low on resources, so the print itself may cause crashes.
3205 
3206   // unless we have NUMAInterleaving enabled, the range of a commit
3207   // is always within a reserve covered by a single VirtualAlloc
3208   // in that case we can just do a single commit for the requested size
3209   if (!UseNUMAInterleaving) {
3210     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
3211       NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3212       return false;
3213     }
3214     if (exec) {
3215       DWORD oldprot;
3216       // Windows doc says to use VirtualProtect to get execute permissions
3217       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
3218         NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3219         return false;
3220       }
3221     }
3222     return true;
3223   } else {
3224 
3225     // when NUMAInterleaving is enabled, the commit might cover a range that
3226     // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3227     // VirtualQuery can help us determine that.  The RegionSize that VirtualQuery
3228     // returns represents the number of bytes that can be committed in one step.
3229     size_t bytes_remaining = bytes;
3230     char * next_alloc_addr = addr;
3231     while (bytes_remaining > 0) {
3232       MEMORY_BASIC_INFORMATION alloc_info;
3233       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3234       size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3235       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
3236                        PAGE_READWRITE) == NULL) {
3237         NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3238                                             exec);)
3239         return false;
3240       }
3241       if (exec) {
3242         DWORD oldprot;
3243         if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
3244                             PAGE_EXECUTE_READWRITE, &oldprot)) {
3245           NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3246                                               exec);)
3247           return false;
3248         }
3249       }
3250       bytes_remaining -= bytes_to_rq;
3251       next_alloc_addr += bytes_to_rq;
3252     }
3253   }
3254   // if we made it this far, return true
3255   return true;
3256 }
3257 
3258 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
3259                           bool exec) {
3260   // alignment_hint is ignored on this OS
3261   return pd_commit_memory(addr, size, exec);
3262 }
3263 
3264 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
3265                                   const char* mesg) {
3266   assert(mesg != NULL, "mesg must be specified");
3267   if (!pd_commit_memory(addr, size, exec)) {
3268     warn_fail_commit_memory(addr, size, exec);
3269     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, "%s", mesg);
3270   }
3271 }
3272 
3273 void os::pd_commit_memory_or_exit(char* addr, size_t size,
3274                                   size_t alignment_hint, bool exec,
3275                                   const char* mesg) {
3276   // alignment_hint is ignored on this OS
3277   pd_commit_memory_or_exit(addr, size, exec, mesg);
3278 }
3279 
3280 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
3281   if (bytes == 0) {
3282     // Don't bother the OS with noops.
3283     return true;
3284   }
3285   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3286   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3287   return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0);
3288 }
3289 
3290 bool os::pd_release_memory(char* addr, size_t bytes) {
3291   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3292 }
3293 
3294 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3295   return os::commit_memory(addr, size, !ExecMem);
3296 }
3297 
3298 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3299   return os::uncommit_memory(addr, size);
3300 }
3301 
3302 static bool protect_pages_individually(char* addr, size_t bytes, unsigned int p, DWORD *old_status) {
3303   uint count = 0;
3304   bool ret = false;
3305   size_t bytes_remaining = bytes;
3306   char * next_protect_addr = addr;
3307 
3308   // Use VirtualQuery() to get the chunk size.
3309   while (bytes_remaining) {
3310     MEMORY_BASIC_INFORMATION alloc_info;
3311     if (VirtualQuery(next_protect_addr, &alloc_info, sizeof(alloc_info)) == 0) {
3312       return false;
3313     }
3314 
3315     size_t bytes_to_protect = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3316     // We used different API at allocate_pages_individually() based on UseNUMAInterleaving,
3317     // but we don't distinguish here as both cases are protected by same API.
3318     ret = VirtualProtect(next_protect_addr, bytes_to_protect, p, old_status) != 0;
3319     warning("Failed protecting pages individually for chunk #%u", count);
3320     if (!ret) {
3321       return false;
3322     }
3323 
3324     bytes_remaining -= bytes_to_protect;
3325     next_protect_addr += bytes_to_protect;
3326     count++;
3327   }
3328   return ret;
3329 }
3330 
3331 // Set protections specified
3332 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3333                         bool is_committed) {
3334   unsigned int p = 0;
3335   switch (prot) {
3336   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3337   case MEM_PROT_READ: p = PAGE_READONLY; break;
3338   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3339   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3340   default:
3341     ShouldNotReachHere();
3342   }
3343 
3344   DWORD old_status;
3345 
3346   // Strange enough, but on Win32 one can change protection only for committed
3347   // memory, not a big deal anyway, as bytes less or equal than 64K
3348   if (!is_committed) {
3349     commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
3350                           "cannot commit protection page");
3351   }
3352   // One cannot use os::guard_memory() here, as on Win32 guard page
3353   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3354   //
3355   // Pages in the region become guard pages. Any attempt to access a guard page
3356   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3357   // the guard page status. Guard pages thus act as a one-time access alarm.
3358   bool ret;
3359   if (UseNUMAInterleaving) {
3360     // If UseNUMAInterleaving is enabled, the pages may have been allocated a chunk at a time,
3361     // so we must protect the chunks individually.
3362     ret = protect_pages_individually(addr, bytes, p, &old_status);
3363   } else {
3364     ret = VirtualProtect(addr, bytes, p, &old_status) != 0;
3365   }
3366 #ifdef ASSERT
3367   if (!ret) {
3368     int err = os::get_last_error();
3369     char buf[256];
3370     size_t buf_len = os::lasterror(buf, sizeof(buf));
3371     warning("INFO: os::protect_memory(" PTR_FORMAT ", " SIZE_FORMAT
3372           ") failed; error='%s' (DOS error/errno=%d)", addr, bytes,
3373           buf_len != 0 ? buf : "<no_error_string>", err);
3374   }
3375 #endif
3376   return ret;
3377 }
3378 
3379 bool os::guard_memory(char* addr, size_t bytes) {
3380   DWORD old_status;
3381   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3382 }
3383 
3384 bool os::unguard_memory(char* addr, size_t bytes) {
3385   DWORD old_status;
3386   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3387 }
3388 
3389 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3390 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3391 void os::numa_make_global(char *addr, size_t bytes)    { }
3392 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3393 bool os::numa_topology_changed()                       { return false; }
3394 size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3395 int os::numa_get_group_id()                            { return 0; }
3396 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3397   if (numa_node_list_holder.get_count() == 0 && size > 0) {
3398     // Provide an answer for UMA systems
3399     ids[0] = 0;
3400     return 1;
3401   } else {
3402     // check for size bigger than actual groups_num
3403     size = MIN2(size, numa_get_groups_num());
3404     for (int i = 0; i < (int)size; i++) {
3405       ids[i] = numa_node_list_holder.get_node_list_entry(i);
3406     }
3407     return size;
3408   }
3409 }
3410 
3411 bool os::get_page_info(char *start, page_info* info) {
3412   return false;
3413 }
3414 
3415 char *os::scan_pages(char *start, char* end, page_info* page_expected,
3416                      page_info* page_found) {
3417   return end;
3418 }
3419 
3420 char* os::non_memory_address_word() {
3421   // Must never look like an address returned by reserve_memory,
3422   // even in its subfields (as defined by the CPU immediate fields,
3423   // if the CPU splits constants across multiple instructions).
3424   return (char*)-1;
3425 }
3426 
3427 #define MAX_ERROR_COUNT 100
3428 #define SYS_THREAD_ERROR 0xffffffffUL
3429 
3430 void os::pd_start_thread(Thread* thread) {
3431   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3432   // Returns previous suspend state:
3433   // 0:  Thread was not suspended
3434   // 1:  Thread is running now
3435   // >1: Thread is still suspended.
3436   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3437 }
3438 
3439 class HighResolutionInterval : public CHeapObj<mtThread> {
3440   // The default timer resolution seems to be 10 milliseconds.
3441   // (Where is this written down?)
3442   // If someone wants to sleep for only a fraction of the default,
3443   // then we set the timer resolution down to 1 millisecond for
3444   // the duration of their interval.
3445   // We carefully set the resolution back, since otherwise we
3446   // seem to incur an overhead (3%?) that we don't need.
3447   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3448   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3449   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3450   // timeBeginPeriod() if the relative error exceeded some threshold.
3451   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3452   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3453   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3454   // resolution timers running.
3455  private:
3456   jlong resolution;
3457  public:
3458   HighResolutionInterval(jlong ms) {
3459     resolution = ms % 10L;
3460     if (resolution != 0) {
3461       MMRESULT result = timeBeginPeriod(1L);
3462     }
3463   }
3464   ~HighResolutionInterval() {
3465     if (resolution != 0) {
3466       MMRESULT result = timeEndPeriod(1L);
3467     }
3468     resolution = 0L;
3469   }
3470 };
3471 
3472 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3473   jlong limit = (jlong) MAXDWORD;
3474 
3475   while (ms > limit) {
3476     int res;
3477     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT) {
3478       return res;
3479     }
3480     ms -= limit;
3481   }
3482 
3483   assert(thread == Thread::current(), "thread consistency check");
3484   OSThread* osthread = thread->osthread();
3485   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3486   int result;
3487   if (interruptable) {
3488     assert(thread->is_Java_thread(), "must be java thread");
3489     JavaThread *jt = (JavaThread *) thread;
3490     ThreadBlockInVM tbivm(jt);
3491 
3492     jt->set_suspend_equivalent();
3493     // cleared by handle_special_suspend_equivalent_condition() or
3494     // java_suspend_self() via check_and_wait_while_suspended()
3495 
3496     HANDLE events[1];
3497     events[0] = osthread->interrupt_event();
3498     HighResolutionInterval *phri=NULL;
3499     if (!ForceTimeHighResolution) {
3500       phri = new HighResolutionInterval(ms);
3501     }
3502     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3503       result = OS_TIMEOUT;
3504     } else {
3505       ResetEvent(osthread->interrupt_event());
3506       osthread->set_interrupted(false);
3507       result = OS_INTRPT;
3508     }
3509     delete phri; //if it is NULL, harmless
3510 
3511     // were we externally suspended while we were waiting?
3512     jt->check_and_wait_while_suspended();
3513   } else {
3514     assert(!thread->is_Java_thread(), "must not be java thread");
3515     Sleep((long) ms);
3516     result = OS_TIMEOUT;
3517   }
3518   return result;
3519 }
3520 
3521 // Short sleep, direct OS call.
3522 //
3523 // ms = 0, means allow others (if any) to run.
3524 //
3525 void os::naked_short_sleep(jlong ms) {
3526   assert(ms < 1000, "Un-interruptable sleep, short time use only");
3527   Sleep(ms);
3528 }
3529 
3530 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3531 void os::infinite_sleep() {
3532   while (true) {    // sleep forever ...
3533     Sleep(100000);  // ... 100 seconds at a time
3534   }
3535 }
3536 
3537 typedef BOOL (WINAPI * STTSignature)(void);
3538 
3539 void os::naked_yield() {
3540   // Consider passing back the return value from SwitchToThread().
3541   SwitchToThread();
3542 }
3543 
3544 // Win32 only gives you access to seven real priorities at a time,
3545 // so we compress Java's ten down to seven.  It would be better
3546 // if we dynamically adjusted relative priorities.
3547 
3548 int os::java_to_os_priority[CriticalPriority + 1] = {
3549   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3550   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3551   THREAD_PRIORITY_LOWEST,                       // 2
3552   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3553   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3554   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3555   THREAD_PRIORITY_NORMAL,                       // 6
3556   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3557   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3558   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3559   THREAD_PRIORITY_HIGHEST,                      // 10 MaxPriority
3560   THREAD_PRIORITY_HIGHEST                       // 11 CriticalPriority
3561 };
3562 
3563 int prio_policy1[CriticalPriority + 1] = {
3564   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3565   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3566   THREAD_PRIORITY_LOWEST,                       // 2
3567   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3568   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3569   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3570   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3571   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3572   THREAD_PRIORITY_HIGHEST,                      // 8
3573   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3574   THREAD_PRIORITY_TIME_CRITICAL,                // 10 MaxPriority
3575   THREAD_PRIORITY_TIME_CRITICAL                 // 11 CriticalPriority
3576 };
3577 
3578 static int prio_init() {
3579   // If ThreadPriorityPolicy is 1, switch tables
3580   if (ThreadPriorityPolicy == 1) {
3581     int i;
3582     for (i = 0; i < CriticalPriority + 1; i++) {
3583       os::java_to_os_priority[i] = prio_policy1[i];
3584     }
3585   }
3586   if (UseCriticalJavaThreadPriority) {
3587     os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority];
3588   }
3589   return 0;
3590 }
3591 
3592 OSReturn os::set_native_priority(Thread* thread, int priority) {
3593   if (!UseThreadPriorities) return OS_OK;
3594   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3595   return ret ? OS_OK : OS_ERR;
3596 }
3597 
3598 OSReturn os::get_native_priority(const Thread* const thread,
3599                                  int* priority_ptr) {
3600   if (!UseThreadPriorities) {
3601     *priority_ptr = java_to_os_priority[NormPriority];
3602     return OS_OK;
3603   }
3604   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3605   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3606     assert(false, "GetThreadPriority failed");
3607     return OS_ERR;
3608   }
3609   *priority_ptr = os_prio;
3610   return OS_OK;
3611 }
3612 
3613 
3614 // Hint to the underlying OS that a task switch would not be good.
3615 // Void return because it's a hint and can fail.
3616 void os::hint_no_preempt() {}
3617 
3618 void os::interrupt(Thread* thread) {
3619   debug_only(Thread::check_for_dangling_thread_pointer(thread);)
3620 
3621   OSThread* osthread = thread->osthread();
3622   osthread->set_interrupted(true);
3623   // More than one thread can get here with the same value of osthread,
3624   // resulting in multiple notifications.  We do, however, want the store
3625   // to interrupted() to be visible to other threads before we post
3626   // the interrupt event.
3627   OrderAccess::release();
3628   SetEvent(osthread->interrupt_event());
3629   // For JSR166:  unpark after setting status
3630   if (thread->is_Java_thread()) {
3631     ((JavaThread*)thread)->parker()->unpark();
3632   }
3633 
3634   ParkEvent * ev = thread->_ParkEvent;
3635   if (ev != NULL) ev->unpark();
3636 }
3637 
3638 
3639 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3640   debug_only(Thread::check_for_dangling_thread_pointer(thread);)
3641 
3642   OSThread* osthread = thread->osthread();
3643   // There is no synchronization between the setting of the interrupt
3644   // and it being cleared here. It is critical - see 6535709 - that
3645   // we only clear the interrupt state, and reset the interrupt event,
3646   // if we are going to report that we were indeed interrupted - else
3647   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3648   // depending on the timing. By checking thread interrupt event to see
3649   // if the thread gets real interrupt thus prevent spurious wakeup.
3650   bool interrupted = osthread->interrupted() && (WaitForSingleObject(osthread->interrupt_event(), 0) == WAIT_OBJECT_0);
3651   if (interrupted && clear_interrupted) {
3652     osthread->set_interrupted(false);
3653     ResetEvent(osthread->interrupt_event());
3654   } // Otherwise leave the interrupted state alone
3655 
3656   return interrupted;
3657 }
3658 
3659 // GetCurrentThreadId() returns DWORD
3660 intx os::current_thread_id()  { return GetCurrentThreadId(); }
3661 
3662 static int _initial_pid = 0;
3663 
3664 int os::current_process_id() {
3665   return (_initial_pid ? _initial_pid : _getpid());
3666 }
3667 
3668 int    os::win32::_vm_page_size              = 0;
3669 int    os::win32::_vm_allocation_granularity = 0;
3670 int    os::win32::_processor_type            = 0;
3671 // Processor level is not available on non-NT systems, use vm_version instead
3672 int    os::win32::_processor_level           = 0;
3673 julong os::win32::_physical_memory           = 0;
3674 size_t os::win32::_default_stack_size        = 0;
3675 
3676 intx          os::win32::_os_thread_limit    = 0;
3677 volatile intx os::win32::_os_thread_count    = 0;
3678 
3679 bool   os::win32::_is_windows_server         = false;
3680 
3681 // 6573254
3682 // Currently, the bug is observed across all the supported Windows releases,
3683 // including the latest one (as of this writing - Windows Server 2012 R2)
3684 bool   os::win32::_has_exit_bug              = true;
3685 
3686 void os::win32::initialize_system_info() {
3687   SYSTEM_INFO si;
3688   GetSystemInfo(&si);
3689   _vm_page_size    = si.dwPageSize;
3690   _vm_allocation_granularity = si.dwAllocationGranularity;
3691   _processor_type  = si.dwProcessorType;
3692   _processor_level = si.wProcessorLevel;
3693   set_processor_count(si.dwNumberOfProcessors);
3694 
3695   MEMORYSTATUSEX ms;
3696   ms.dwLength = sizeof(ms);
3697 
3698   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3699   // dwMemoryLoad (% of memory in use)
3700   GlobalMemoryStatusEx(&ms);
3701   _physical_memory = ms.ullTotalPhys;
3702 
3703   if (FLAG_IS_DEFAULT(MaxRAM)) {
3704     // Adjust MaxRAM according to the maximum virtual address space available.
3705     FLAG_SET_DEFAULT(MaxRAM, MIN2(MaxRAM, (uint64_t) ms.ullTotalVirtual));
3706   }
3707 
3708   OSVERSIONINFOEX oi;
3709   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3710   GetVersionEx((OSVERSIONINFO*)&oi);
3711   switch (oi.dwPlatformId) {
3712   case VER_PLATFORM_WIN32_NT:
3713     {
3714       int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3715       if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3716           oi.wProductType == VER_NT_SERVER) {
3717         _is_windows_server = true;
3718       }
3719     }
3720     break;
3721   default: fatal("Unknown platform");
3722   }
3723 
3724   _default_stack_size = os::current_stack_size();
3725   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3726   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3727          "stack size not a multiple of page size");
3728 
3729   initialize_performance_counter();
3730 }
3731 
3732 
3733 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf,
3734                                       int ebuflen) {
3735   char path[MAX_PATH];
3736   DWORD size;
3737   DWORD pathLen = (DWORD)sizeof(path);
3738   HINSTANCE result = NULL;
3739 
3740   // only allow library name without path component
3741   assert(strchr(name, '\\') == NULL, "path not allowed");
3742   assert(strchr(name, ':') == NULL, "path not allowed");
3743   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3744     jio_snprintf(ebuf, ebuflen,
3745                  "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3746     return NULL;
3747   }
3748 
3749   // search system directory
3750   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3751     if (size >= pathLen) {
3752       return NULL; // truncated
3753     }
3754     if (jio_snprintf(path + size, pathLen - size, "\\%s", name) == -1) {
3755       return NULL; // truncated
3756     }
3757     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3758       return result;
3759     }
3760   }
3761 
3762   // try Windows directory
3763   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3764     if (size >= pathLen) {
3765       return NULL; // truncated
3766     }
3767     if (jio_snprintf(path + size, pathLen - size, "\\%s", name) == -1) {
3768       return NULL; // truncated
3769     }
3770     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3771       return result;
3772     }
3773   }
3774 
3775   jio_snprintf(ebuf, ebuflen,
3776                "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3777   return NULL;
3778 }
3779 
3780 #define MAXIMUM_THREADS_TO_KEEP (16 * MAXIMUM_WAIT_OBJECTS)
3781 #define EXIT_TIMEOUT 300000 /* 5 minutes */
3782 
3783 static BOOL CALLBACK init_crit_sect_call(PINIT_ONCE, PVOID pcrit_sect, PVOID*) {
3784   InitializeCriticalSection((CRITICAL_SECTION*)pcrit_sect);
3785   return TRUE;
3786 }
3787 
3788 int os::win32::exit_process_or_thread(Ept what, int exit_code) {
3789   // Basic approach:
3790   //  - Each exiting thread registers its intent to exit and then does so.
3791   //  - A thread trying to terminate the process must wait for all
3792   //    threads currently exiting to complete their exit.
3793 
3794   if (os::win32::has_exit_bug()) {
3795     // The array holds handles of the threads that have started exiting by calling
3796     // _endthreadex().
3797     // Should be large enough to avoid blocking the exiting thread due to lack of
3798     // a free slot.
3799     static HANDLE handles[MAXIMUM_THREADS_TO_KEEP];
3800     static int handle_count = 0;
3801 
3802     static INIT_ONCE init_once_crit_sect = INIT_ONCE_STATIC_INIT;
3803     static CRITICAL_SECTION crit_sect;
3804     static volatile DWORD process_exiting = 0;
3805     int i, j;
3806     DWORD res;
3807     HANDLE hproc, hthr;
3808 
3809     // We only attempt to register threads until a process exiting
3810     // thread manages to set the process_exiting flag. Any threads
3811     // that come through here after the process_exiting flag is set
3812     // are unregistered and will be caught in the SuspendThread()
3813     // infinite loop below.
3814     bool registered = false;
3815 
3816     // The first thread that reached this point, initializes the critical section.
3817     if (!InitOnceExecuteOnce(&init_once_crit_sect, init_crit_sect_call, &crit_sect, NULL)) {
3818       warning("crit_sect initialization failed in %s: %d\n", __FILE__, __LINE__);
3819     } else if (OrderAccess::load_acquire(&process_exiting) == 0) {
3820       if (what != EPT_THREAD) {
3821         // Atomically set process_exiting before the critical section
3822         // to increase the visibility between racing threads.
3823         Atomic::cmpxchg(GetCurrentThreadId(), &process_exiting, (DWORD)0);
3824       }
3825       EnterCriticalSection(&crit_sect);
3826 
3827       if (what == EPT_THREAD && OrderAccess::load_acquire(&process_exiting) == 0) {
3828         // Remove from the array those handles of the threads that have completed exiting.
3829         for (i = 0, j = 0; i < handle_count; ++i) {
3830           res = WaitForSingleObject(handles[i], 0 /* don't wait */);
3831           if (res == WAIT_TIMEOUT) {
3832             handles[j++] = handles[i];
3833           } else {
3834             if (res == WAIT_FAILED) {
3835               warning("WaitForSingleObject failed (%u) in %s: %d\n",
3836                       GetLastError(), __FILE__, __LINE__);
3837             }
3838             // Don't keep the handle, if we failed waiting for it.
3839             CloseHandle(handles[i]);
3840           }
3841         }
3842 
3843         // If there's no free slot in the array of the kept handles, we'll have to
3844         // wait until at least one thread completes exiting.
3845         if ((handle_count = j) == MAXIMUM_THREADS_TO_KEEP) {
3846           // Raise the priority of the oldest exiting thread to increase its chances
3847           // to complete sooner.
3848           SetThreadPriority(handles[0], THREAD_PRIORITY_ABOVE_NORMAL);
3849           res = WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, handles, FALSE, EXIT_TIMEOUT);
3850           if (res >= WAIT_OBJECT_0 && res < (WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS)) {
3851             i = (res - WAIT_OBJECT_0);
3852             handle_count = MAXIMUM_THREADS_TO_KEEP - 1;
3853             for (; i < handle_count; ++i) {
3854               handles[i] = handles[i + 1];
3855             }
3856           } else {
3857             warning("WaitForMultipleObjects %s (%u) in %s: %d\n",
3858                     (res == WAIT_FAILED ? "failed" : "timed out"),
3859                     GetLastError(), __FILE__, __LINE__);
3860             // Don't keep handles, if we failed waiting for them.
3861             for (i = 0; i < MAXIMUM_THREADS_TO_KEEP; ++i) {
3862               CloseHandle(handles[i]);
3863             }
3864             handle_count = 0;
3865           }
3866         }
3867 
3868         // Store a duplicate of the current thread handle in the array of handles.
3869         hproc = GetCurrentProcess();
3870         hthr = GetCurrentThread();
3871         if (!DuplicateHandle(hproc, hthr, hproc, &handles[handle_count],
3872                              0, FALSE, DUPLICATE_SAME_ACCESS)) {
3873           warning("DuplicateHandle failed (%u) in %s: %d\n",
3874                   GetLastError(), __FILE__, __LINE__);
3875 
3876           // We can't register this thread (no more handles) so this thread
3877           // may be racing with a thread that is calling exit(). If the thread
3878           // that is calling exit() has managed to set the process_exiting
3879           // flag, then this thread will be caught in the SuspendThread()
3880           // infinite loop below which closes that race. A small timing
3881           // window remains before the process_exiting flag is set, but it
3882           // is only exposed when we are out of handles.
3883         } else {
3884           ++handle_count;
3885           registered = true;
3886 
3887           // The current exiting thread has stored its handle in the array, and now
3888           // should leave the critical section before calling _endthreadex().
3889         }
3890 
3891       } else if (what != EPT_THREAD && handle_count > 0) {
3892         jlong start_time, finish_time, timeout_left;
3893         // Before ending the process, make sure all the threads that had called
3894         // _endthreadex() completed.
3895 
3896         // Set the priority level of the current thread to the same value as
3897         // the priority level of exiting threads.
3898         // This is to ensure it will be given a fair chance to execute if
3899         // the timeout expires.
3900         hthr = GetCurrentThread();
3901         SetThreadPriority(hthr, THREAD_PRIORITY_ABOVE_NORMAL);
3902         start_time = os::javaTimeNanos();
3903         finish_time = start_time + ((jlong)EXIT_TIMEOUT * 1000000L);
3904         for (i = 0; ; ) {
3905           int portion_count = handle_count - i;
3906           if (portion_count > MAXIMUM_WAIT_OBJECTS) {
3907             portion_count = MAXIMUM_WAIT_OBJECTS;
3908           }
3909           for (j = 0; j < portion_count; ++j) {
3910             SetThreadPriority(handles[i + j], THREAD_PRIORITY_ABOVE_NORMAL);
3911           }
3912           timeout_left = (finish_time - start_time) / 1000000L;
3913           if (timeout_left < 0) {
3914             timeout_left = 0;
3915           }
3916           res = WaitForMultipleObjects(portion_count, handles + i, TRUE, timeout_left);
3917           if (res == WAIT_FAILED || res == WAIT_TIMEOUT) {
3918             warning("WaitForMultipleObjects %s (%u) in %s: %d\n",
3919                     (res == WAIT_FAILED ? "failed" : "timed out"),
3920                     GetLastError(), __FILE__, __LINE__);
3921             // Reset portion_count so we close the remaining
3922             // handles due to this error.
3923             portion_count = handle_count - i;
3924           }
3925           for (j = 0; j < portion_count; ++j) {
3926             CloseHandle(handles[i + j]);
3927           }
3928           if ((i += portion_count) >= handle_count) {
3929             break;
3930           }
3931           start_time = os::javaTimeNanos();
3932         }
3933         handle_count = 0;
3934       }
3935 
3936       LeaveCriticalSection(&crit_sect);
3937     }
3938 
3939     if (!registered &&
3940         OrderAccess::load_acquire(&process_exiting) != 0 &&
3941         process_exiting != GetCurrentThreadId()) {
3942       // Some other thread is about to call exit(), so we don't let
3943       // the current unregistered thread proceed to exit() or _endthreadex()
3944       while (true) {
3945         SuspendThread(GetCurrentThread());
3946         // Avoid busy-wait loop, if SuspendThread() failed.
3947         Sleep(EXIT_TIMEOUT);
3948       }
3949     }
3950   }
3951 
3952   // We are here if either
3953   // - there's no 'race at exit' bug on this OS release;
3954   // - initialization of the critical section failed (unlikely);
3955   // - the current thread has registered itself and left the critical section;
3956   // - the process-exiting thread has raised the flag and left the critical section.
3957   if (what == EPT_THREAD) {
3958     _endthreadex((unsigned)exit_code);
3959   } else if (what == EPT_PROCESS) {
3960     ::exit(exit_code);
3961   } else {
3962     _exit(exit_code);
3963   }
3964 
3965   // Should not reach here
3966   return exit_code;
3967 }
3968 
3969 #undef EXIT_TIMEOUT
3970 
3971 void os::win32::setmode_streams() {
3972   _setmode(_fileno(stdin), _O_BINARY);
3973   _setmode(_fileno(stdout), _O_BINARY);
3974   _setmode(_fileno(stderr), _O_BINARY);
3975 }
3976 
3977 
3978 bool os::is_debugger_attached() {
3979   return IsDebuggerPresent() ? true : false;
3980 }
3981 
3982 
3983 void os::wait_for_keypress_at_exit(void) {
3984   if (PauseAtExit) {
3985     fprintf(stderr, "Press any key to continue...\n");
3986     fgetc(stdin);
3987   }
3988 }
3989 
3990 
3991 bool os::message_box(const char* title, const char* message) {
3992   int result = MessageBox(NULL, message, title,
3993                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3994   return result == IDYES;
3995 }
3996 
3997 #ifndef PRODUCT
3998 #ifndef _WIN64
3999 // Helpers to check whether NX protection is enabled
4000 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
4001   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
4002       pex->ExceptionRecord->NumberParameters > 0 &&
4003       pex->ExceptionRecord->ExceptionInformation[0] ==
4004       EXCEPTION_INFO_EXEC_VIOLATION) {
4005     return EXCEPTION_EXECUTE_HANDLER;
4006   }
4007   return EXCEPTION_CONTINUE_SEARCH;
4008 }
4009 
4010 void nx_check_protection() {
4011   // If NX is enabled we'll get an exception calling into code on the stack
4012   char code[] = { (char)0xC3 }; // ret
4013   void *code_ptr = (void *)code;
4014   __try {
4015     __asm call code_ptr
4016   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
4017     tty->print_raw_cr("NX protection detected.");
4018   }
4019 }
4020 #endif // _WIN64
4021 #endif // PRODUCT
4022 
4023 // This is called _before_ the global arguments have been parsed
4024 void os::init(void) {
4025   _initial_pid = _getpid();
4026 
4027   init_random(1234567);
4028 
4029   win32::initialize_system_info();
4030   win32::setmode_streams();
4031   init_page_sizes((size_t) win32::vm_page_size());
4032 
4033   // This may be overridden later when argument processing is done.
4034   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation, false);
4035 
4036   // Initialize main_process and main_thread
4037   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
4038   if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
4039                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
4040     fatal("DuplicateHandle failed\n");
4041   }
4042   main_thread_id = (int) GetCurrentThreadId();
4043 
4044   // initialize fast thread access - only used for 32-bit
4045   win32::initialize_thread_ptr_offset();
4046 }
4047 
4048 // To install functions for atexit processing
4049 extern "C" {
4050   static void perfMemory_exit_helper() {
4051     perfMemory_exit();
4052   }
4053 }
4054 
4055 static jint initSock();
4056 
4057 // this is called _after_ the global arguments have been parsed
4058 jint os::init_2(void) {
4059   // Setup Windows Exceptions
4060 
4061   // for debugging float code generation bugs
4062   if (ForceFloatExceptions) {
4063 #ifndef  _WIN64
4064     static long fp_control_word = 0;
4065     __asm { fstcw fp_control_word }
4066     // see Intel PPro Manual, Vol. 2, p 7-16
4067     const long precision = 0x20;
4068     const long underflow = 0x10;
4069     const long overflow  = 0x08;
4070     const long zero_div  = 0x04;
4071     const long denorm    = 0x02;
4072     const long invalid   = 0x01;
4073     fp_control_word |= invalid;
4074     __asm { fldcw fp_control_word }
4075 #endif
4076   }
4077 
4078   // If stack_commit_size is 0, windows will reserve the default size,
4079   // but only commit a small portion of it.
4080   size_t stack_commit_size = align_up(ThreadStackSize*K, os::vm_page_size());
4081   size_t default_reserve_size = os::win32::default_stack_size();
4082   size_t actual_reserve_size = stack_commit_size;
4083   if (stack_commit_size < default_reserve_size) {
4084     // If stack_commit_size == 0, we want this too
4085     actual_reserve_size = default_reserve_size;
4086   }
4087 
4088   // Check minimum allowable stack size for thread creation and to initialize
4089   // the java system classes, including StackOverflowError - depends on page
4090   // size.  Add two 4K pages for compiler2 recursion in main thread.
4091   // Add in 4*BytesPerWord 4K pages to account for VM stack during
4092   // class initialization depending on 32 or 64 bit VM.
4093   size_t min_stack_allowed =
4094             (size_t)(JavaThread::stack_guard_zone_size() +
4095                      JavaThread::stack_shadow_zone_size() +
4096                      (4*BytesPerWord COMPILER2_PRESENT(+2)) * 4 * K);
4097 
4098   min_stack_allowed = align_up(min_stack_allowed, os::vm_page_size());
4099 
4100   if (actual_reserve_size < min_stack_allowed) {
4101     tty->print_cr("\nThe Java thread stack size specified is too small. "
4102                   "Specify at least %dk",
4103                   min_stack_allowed / K);
4104     return JNI_ERR;
4105   }
4106 
4107   JavaThread::set_stack_size_at_create(stack_commit_size);
4108 
4109   // Calculate theoretical max. size of Threads to guard gainst artifical
4110   // out-of-memory situations, where all available address-space has been
4111   // reserved by thread stacks.
4112   assert(actual_reserve_size != 0, "Must have a stack");
4113 
4114   // Calculate the thread limit when we should start doing Virtual Memory
4115   // banging. Currently when the threads will have used all but 200Mb of space.
4116   //
4117   // TODO: consider performing a similar calculation for commit size instead
4118   // as reserve size, since on a 64-bit platform we'll run into that more
4119   // often than running out of virtual memory space.  We can use the
4120   // lower value of the two calculations as the os_thread_limit.
4121   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
4122   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
4123 
4124   // at exit methods are called in the reverse order of their registration.
4125   // there is no limit to the number of functions registered. atexit does
4126   // not set errno.
4127 
4128   if (PerfAllowAtExitRegistration) {
4129     // only register atexit functions if PerfAllowAtExitRegistration is set.
4130     // atexit functions can be delayed until process exit time, which
4131     // can be problematic for embedded VM situations. Embedded VMs should
4132     // call DestroyJavaVM() to assure that VM resources are released.
4133 
4134     // note: perfMemory_exit_helper atexit function may be removed in
4135     // the future if the appropriate cleanup code can be added to the
4136     // VM_Exit VMOperation's doit method.
4137     if (atexit(perfMemory_exit_helper) != 0) {
4138       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4139     }
4140   }
4141 
4142 #ifndef _WIN64
4143   // Print something if NX is enabled (win32 on AMD64)
4144   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4145 #endif
4146 
4147   // initialize thread priority policy
4148   prio_init();
4149 
4150   if (UseNUMA && !ForceNUMA) {
4151     UseNUMA = false; // We don't fully support this yet
4152   }
4153 
4154   if (UseNUMAInterleaving) {
4155     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4156     bool success = numa_interleaving_init();
4157     if (!success) UseNUMAInterleaving = false;
4158   }
4159 
4160   if (initSock() != JNI_OK) {
4161     return JNI_ERR;
4162   }
4163 
4164   SymbolEngine::recalc_search_path();
4165 
4166   // Initialize data for jdk.internal.misc.Signal
4167   if (!ReduceSignalUsage) {
4168     jdk_misc_signal_init();
4169   }
4170 
4171   return JNI_OK;
4172 }
4173 
4174 // Mark the polling page as unreadable
4175 void os::make_polling_page_unreadable(void) {
4176   DWORD old_status;
4177   if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4178                       PAGE_NOACCESS, &old_status)) {
4179     fatal("Could not disable polling page");
4180   }
4181 }
4182 
4183 // Mark the polling page as readable
4184 void os::make_polling_page_readable(void) {
4185   DWORD old_status;
4186   if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4187                       PAGE_READONLY, &old_status)) {
4188     fatal("Could not enable polling page");
4189   }
4190 }
4191 
4192 // combine the high and low DWORD into a ULONGLONG
4193 static ULONGLONG make_double_word(DWORD high_word, DWORD low_word) {
4194   ULONGLONG value = high_word;
4195   value <<= sizeof(high_word) * 8;
4196   value |= low_word;
4197   return value;
4198 }
4199 
4200 // Transfers data from WIN32_FILE_ATTRIBUTE_DATA structure to struct stat
4201 static void file_attribute_data_to_stat(struct stat* sbuf, WIN32_FILE_ATTRIBUTE_DATA file_data) {
4202   ::memset((void*)sbuf, 0, sizeof(struct stat));
4203   sbuf->st_size = (_off_t)make_double_word(file_data.nFileSizeHigh, file_data.nFileSizeLow);
4204   sbuf->st_mtime = make_double_word(file_data.ftLastWriteTime.dwHighDateTime,
4205                                   file_data.ftLastWriteTime.dwLowDateTime);
4206   sbuf->st_ctime = make_double_word(file_data.ftCreationTime.dwHighDateTime,
4207                                   file_data.ftCreationTime.dwLowDateTime);
4208   sbuf->st_atime = make_double_word(file_data.ftLastAccessTime.dwHighDateTime,
4209                                   file_data.ftLastAccessTime.dwLowDateTime);
4210   if ((file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
4211     sbuf->st_mode |= S_IFDIR;
4212   } else {
4213     sbuf->st_mode |= S_IFREG;
4214   }
4215 }
4216 
4217 // The following function is adapted from java.base/windows/native/libjava/canonicalize_md.c
4218 // Creates an UNC path from a single byte path. Return buffer is
4219 // allocated in C heap and needs to be freed by the caller.
4220 // Returns NULL on error.
4221 static wchar_t* create_unc_path(const char* path, errno_t &err) {
4222   wchar_t* wpath = NULL;
4223   size_t converted_chars = 0;
4224   size_t path_len = strlen(path) + 1; // includes the terminating NULL
4225   if (path[0] == '\\' && path[1] == '\\') {
4226     if (path[2] == '?' && path[3] == '\\'){
4227       // if it already has a \\?\ don't do the prefix
4228       wpath = (wchar_t*)os::malloc(path_len * sizeof(wchar_t), mtInternal);
4229       if (wpath != NULL) {
4230         err = ::mbstowcs_s(&converted_chars, wpath, path_len, path, path_len);
4231       } else {
4232         err = ENOMEM;
4233       }
4234     } else {
4235       // only UNC pathname includes double slashes here
4236       wpath = (wchar_t*)os::malloc((path_len + 7) * sizeof(wchar_t), mtInternal);
4237       if (wpath != NULL) {
4238         ::wcscpy(wpath, L"\\\\?\\UNC\0");
4239         err = ::mbstowcs_s(&converted_chars, &wpath[7], path_len, path, path_len);
4240       } else {
4241         err = ENOMEM;
4242       }
4243     }
4244   } else {
4245     wpath = (wchar_t*)os::malloc((path_len + 4) * sizeof(wchar_t), mtInternal);
4246     if (wpath != NULL) {
4247       ::wcscpy(wpath, L"\\\\?\\\0");
4248       err = ::mbstowcs_s(&converted_chars, &wpath[4], path_len, path, path_len);
4249     } else {
4250       err = ENOMEM;
4251     }
4252   }
4253   return wpath;
4254 }
4255 
4256 static void destroy_unc_path(wchar_t* wpath) {
4257   os::free(wpath);
4258 }
4259 
4260 int os::stat(const char *path, struct stat *sbuf) {
4261   char* pathbuf = (char*)os::strdup(path, mtInternal);
4262   if (pathbuf == NULL) {
4263     errno = ENOMEM;
4264     return -1;
4265   }
4266   os::native_path(pathbuf);
4267   int ret;
4268   WIN32_FILE_ATTRIBUTE_DATA file_data;
4269   // Not using stat() to avoid the problem described in JDK-6539723
4270   if (strlen(path) < MAX_PATH) {
4271     BOOL bret = ::GetFileAttributesExA(pathbuf, GetFileExInfoStandard, &file_data);
4272     if (!bret) {
4273       errno = ::GetLastError();
4274       ret = -1;
4275     }
4276     else {
4277       file_attribute_data_to_stat(sbuf, file_data);
4278       ret = 0;
4279     }
4280   } else {
4281     errno_t err = ERROR_SUCCESS;
4282     wchar_t* wpath = create_unc_path(pathbuf, err);
4283     if (err != ERROR_SUCCESS) {
4284       if (wpath != NULL) {
4285         destroy_unc_path(wpath);
4286       }
4287       os::free(pathbuf);
4288       errno = err;
4289       return -1;
4290     }
4291     BOOL bret = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &file_data);
4292     if (!bret) {
4293       errno = ::GetLastError();
4294       ret = -1;
4295     } else {
4296       file_attribute_data_to_stat(sbuf, file_data);
4297       ret = 0;
4298     }
4299     destroy_unc_path(wpath);
4300   }
4301   os::free(pathbuf);
4302   return ret;
4303 }
4304 
4305 
4306 #define FT2INT64(ft) \
4307   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4308 
4309 
4310 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4311 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4312 // of a thread.
4313 //
4314 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4315 // the fast estimate available on the platform.
4316 
4317 // current_thread_cpu_time() is not optimized for Windows yet
4318 jlong os::current_thread_cpu_time() {
4319   // return user + sys since the cost is the same
4320   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4321 }
4322 
4323 jlong os::thread_cpu_time(Thread* thread) {
4324   // consistent with what current_thread_cpu_time() returns.
4325   return os::thread_cpu_time(thread, true /* user+sys */);
4326 }
4327 
4328 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4329   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4330 }
4331 
4332 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4333   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4334   // If this function changes, os::is_thread_cpu_time_supported() should too
4335   FILETIME CreationTime;
4336   FILETIME ExitTime;
4337   FILETIME KernelTime;
4338   FILETIME UserTime;
4339 
4340   if (GetThreadTimes(thread->osthread()->thread_handle(), &CreationTime,
4341                       &ExitTime, &KernelTime, &UserTime) == 0) {
4342     return -1;
4343   } else if (user_sys_cpu_time) {
4344     return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4345   } else {
4346     return FT2INT64(UserTime) * 100;
4347   }
4348 }
4349 
4350 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4351   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4352   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4353   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4354   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4355 }
4356 
4357 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4358   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4359   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4360   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4361   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4362 }
4363 
4364 bool os::is_thread_cpu_time_supported() {
4365   // see os::thread_cpu_time
4366   FILETIME CreationTime;
4367   FILETIME ExitTime;
4368   FILETIME KernelTime;
4369   FILETIME UserTime;
4370 
4371   if (GetThreadTimes(GetCurrentThread(), &CreationTime, &ExitTime,
4372                       &KernelTime, &UserTime) == 0) {
4373     return false;
4374   } else {
4375     return true;
4376   }
4377 }
4378 
4379 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4380 // It does have primitives (PDH API) to get CPU usage and run queue length.
4381 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4382 // If we wanted to implement loadavg on Windows, we have a few options:
4383 //
4384 // a) Query CPU usage and run queue length and "fake" an answer by
4385 //    returning the CPU usage if it's under 100%, and the run queue
4386 //    length otherwise.  It turns out that querying is pretty slow
4387 //    on Windows, on the order of 200 microseconds on a fast machine.
4388 //    Note that on the Windows the CPU usage value is the % usage
4389 //    since the last time the API was called (and the first call
4390 //    returns 100%), so we'd have to deal with that as well.
4391 //
4392 // b) Sample the "fake" answer using a sampling thread and store
4393 //    the answer in a global variable.  The call to loadavg would
4394 //    just return the value of the global, avoiding the slow query.
4395 //
4396 // c) Sample a better answer using exponential decay to smooth the
4397 //    value.  This is basically the algorithm used by UNIX kernels.
4398 //
4399 // Note that sampling thread starvation could affect both (b) and (c).
4400 int os::loadavg(double loadavg[], int nelem) {
4401   return -1;
4402 }
4403 
4404 
4405 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4406 bool os::dont_yield() {
4407   return DontYieldALot;
4408 }
4409 
4410 // This method is a slightly reworked copy of JDK's sysOpen
4411 // from src/windows/hpi/src/sys_api_md.c
4412 
4413 int os::open(const char *path, int oflag, int mode) {
4414   char* pathbuf = (char*)os::strdup(path, mtInternal);
4415   if (pathbuf == NULL) {
4416     errno = ENOMEM;
4417     return -1;
4418   }
4419   os::native_path(pathbuf);
4420   int ret;
4421   if (strlen(path) < MAX_PATH) {
4422     ret = ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4423   } else {
4424     errno_t err = ERROR_SUCCESS;
4425     wchar_t* wpath = create_unc_path(pathbuf, err);
4426     if (err != ERROR_SUCCESS) {
4427       if (wpath != NULL) {
4428         destroy_unc_path(wpath);
4429       }
4430       os::free(pathbuf);
4431       errno = err;
4432       return -1;
4433     }
4434     ret = ::_wopen(wpath, oflag | O_BINARY | O_NOINHERIT, mode);
4435     if (ret == -1) {
4436       errno = ::GetLastError();
4437     }
4438     destroy_unc_path(wpath);
4439   }
4440   os::free(pathbuf);
4441   return ret;
4442 }
4443 
4444 FILE* os::open(int fd, const char* mode) {
4445   return ::_fdopen(fd, mode);
4446 }
4447 
4448 // Is a (classpath) directory empty?
4449 bool os::dir_is_empty(const char* path) {
4450   char* search_path = (char*)os::malloc(strlen(path) + 3, mtInternal);
4451   if (search_path == NULL) {
4452     errno = ENOMEM;
4453     return false;
4454   }
4455   strcpy(search_path, path);
4456   os::native_path(search_path);
4457   // Append "*", or possibly "\\*", to path
4458   if (search_path[1] == ':' &&
4459        (search_path[2] == '\0' ||
4460          (search_path[2] == '\\' && search_path[3] == '\0'))) {
4461     // No '\\' needed for cases like "Z:" or "Z:\"
4462     strcat(search_path, "*");
4463   }
4464   else {
4465     strcat(search_path, "\\*");
4466   }
4467   errno_t err = ERROR_SUCCESS;
4468   wchar_t* wpath = create_unc_path(search_path, err);
4469   if (err != ERROR_SUCCESS) {
4470     if (wpath != NULL) {
4471       destroy_unc_path(wpath);
4472     }
4473     os::free(search_path);
4474     errno = err;
4475     return false;
4476   }
4477   WIN32_FIND_DATAW fd;
4478   HANDLE f = ::FindFirstFileW(wpath, &fd);
4479   destroy_unc_path(wpath);
4480   bool is_empty = true;
4481   if (f != INVALID_HANDLE_VALUE) {
4482     while (is_empty && ::FindNextFileW(f, &fd)) {
4483       // An empty directory contains only the current directory file
4484       // and the previous directory file.
4485       if ((wcscmp(fd.cFileName, L".") != 0) &&
4486           (wcscmp(fd.cFileName, L"..") != 0)) {
4487         is_empty = false;
4488       }
4489     }
4490     FindClose(f);
4491   }
4492   os::free(search_path);
4493   return is_empty;
4494 }
4495 
4496 // create binary file, rewriting existing file if required
4497 int os::create_binary_file(const char* path, bool rewrite_existing) {
4498   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4499   if (!rewrite_existing) {
4500     oflags |= _O_EXCL;
4501   }
4502   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4503 }
4504 
4505 // return current position of file pointer
4506 jlong os::current_file_offset(int fd) {
4507   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4508 }
4509 
4510 // move file pointer to the specified offset
4511 jlong os::seek_to_file_offset(int fd, jlong offset) {
4512   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4513 }
4514 
4515 
4516 jlong os::lseek(int fd, jlong offset, int whence) {
4517   return (jlong) ::_lseeki64(fd, offset, whence);
4518 }
4519 
4520 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
4521   OVERLAPPED ov;
4522   DWORD nread;
4523   BOOL result;
4524 
4525   ZeroMemory(&ov, sizeof(ov));
4526   ov.Offset = (DWORD)offset;
4527   ov.OffsetHigh = (DWORD)(offset >> 32);
4528 
4529   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4530 
4531   result = ReadFile(h, (LPVOID)buf, nBytes, &nread, &ov);
4532 
4533   return result ? nread : 0;
4534 }
4535 
4536 
4537 // This method is a slightly reworked copy of JDK's sysNativePath
4538 // from src/windows/hpi/src/path_md.c
4539 
4540 // Convert a pathname to native format.  On win32, this involves forcing all
4541 // separators to be '\\' rather than '/' (both are legal inputs, but Win95
4542 // sometimes rejects '/') and removing redundant separators.  The input path is
4543 // assumed to have been converted into the character encoding used by the local
4544 // system.  Because this might be a double-byte encoding, care is taken to
4545 // treat double-byte lead characters correctly.
4546 //
4547 // On Posix platforms, this function is a noop; it just returns the
4548 // input argument unchanged.
4549 //
4550 // This procedure modifies the given path in place, as the result is never
4551 // longer than the original.  There is no error return; this operation always
4552 // succeeds.
4553 char * os::native_path(char *path) {
4554   char *src = path, *dst = path, *end = path;
4555   char *colon = NULL;  // If a drive specifier is found, this will
4556                        // point to the colon following the drive letter
4557 
4558   // Assumption: '/', '\\', ':', and drive letters are never lead bytes
4559   assert(((!::IsDBCSLeadByte('/')) && (!::IsDBCSLeadByte('\\'))
4560           && (!::IsDBCSLeadByte(':'))), "Illegal lead byte");
4561 
4562   // Check for leading separators
4563 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4564   while (isfilesep(*src)) {
4565     src++;
4566   }
4567 
4568   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4569     // Remove leading separators if followed by drive specifier.  This
4570     // hack is necessary to support file URLs containing drive
4571     // specifiers (e.g., "file://c:/path").  As a side effect,
4572     // "/c:/path" can be used as an alternative to "c:/path".
4573     *dst++ = *src++;
4574     colon = dst;
4575     *dst++ = ':';
4576     src++;
4577   } else {
4578     src = path;
4579     if (isfilesep(src[0]) && isfilesep(src[1])) {
4580       // UNC pathname: Retain first separator; leave src pointed at
4581       // second separator so that further separators will be collapsed
4582       // into the second separator.  The result will be a pathname
4583       // beginning with "\\\\" followed (most likely) by a host name.
4584       src = dst = path + 1;
4585       path[0] = '\\';     // Force first separator to '\\'
4586     }
4587   }
4588 
4589   end = dst;
4590 
4591   // Remove redundant separators from remainder of path, forcing all
4592   // separators to be '\\' rather than '/'. Also, single byte space
4593   // characters are removed from the end of the path because those
4594   // are not legal ending characters on this operating system.
4595   //
4596   while (*src != '\0') {
4597     if (isfilesep(*src)) {
4598       *dst++ = '\\'; src++;
4599       while (isfilesep(*src)) src++;
4600       if (*src == '\0') {
4601         // Check for trailing separator
4602         end = dst;
4603         if (colon == dst - 2) break;  // "z:\\"
4604         if (dst == path + 1) break;   // "\\"
4605         if (dst == path + 2 && isfilesep(path[0])) {
4606           // "\\\\" is not collapsed to "\\" because "\\\\" marks the
4607           // beginning of a UNC pathname.  Even though it is not, by
4608           // itself, a valid UNC pathname, we leave it as is in order
4609           // to be consistent with the path canonicalizer as well
4610           // as the win32 APIs, which treat this case as an invalid
4611           // UNC pathname rather than as an alias for the root
4612           // directory of the current drive.
4613           break;
4614         }
4615         end = --dst;  // Path does not denote a root directory, so
4616                       // remove trailing separator
4617         break;
4618       }
4619       end = dst;
4620     } else {
4621       if (::IsDBCSLeadByte(*src)) {  // Copy a double-byte character
4622         *dst++ = *src++;
4623         if (*src) *dst++ = *src++;
4624         end = dst;
4625       } else {  // Copy a single-byte character
4626         char c = *src++;
4627         *dst++ = c;
4628         // Space is not a legal ending character
4629         if (c != ' ') end = dst;
4630       }
4631     }
4632   }
4633 
4634   *end = '\0';
4635 
4636   // For "z:", add "." to work around a bug in the C runtime library
4637   if (colon == dst - 1) {
4638     path[2] = '.';
4639     path[3] = '\0';
4640   }
4641 
4642   return path;
4643 }
4644 
4645 // This code is a copy of JDK's sysSetLength
4646 // from src/windows/hpi/src/sys_api_md.c
4647 
4648 int os::ftruncate(int fd, jlong length) {
4649   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4650   long high = (long)(length >> 32);
4651   DWORD ret;
4652 
4653   if (h == (HANDLE)(-1)) {
4654     return -1;
4655   }
4656 
4657   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4658   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4659     return -1;
4660   }
4661 
4662   if (::SetEndOfFile(h) == FALSE) {
4663     return -1;
4664   }
4665 
4666   return 0;
4667 }
4668 
4669 int os::get_fileno(FILE* fp) {
4670   return _fileno(fp);
4671 }
4672 
4673 // This code is a copy of JDK's sysSync
4674 // from src/windows/hpi/src/sys_api_md.c
4675 // except for the legacy workaround for a bug in Win 98
4676 
4677 int os::fsync(int fd) {
4678   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4679 
4680   if ((!::FlushFileBuffers(handle)) &&
4681       (GetLastError() != ERROR_ACCESS_DENIED)) {
4682     // from winerror.h
4683     return -1;
4684   }
4685   return 0;
4686 }
4687 
4688 static int nonSeekAvailable(int, long *);
4689 static int stdinAvailable(int, long *);
4690 
4691 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4692 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4693 
4694 // This code is a copy of JDK's sysAvailable
4695 // from src/windows/hpi/src/sys_api_md.c
4696 
4697 int os::available(int fd, jlong *bytes) {
4698   jlong cur, end;
4699   struct _stati64 stbuf64;
4700 
4701   if (::_fstati64(fd, &stbuf64) >= 0) {
4702     int mode = stbuf64.st_mode;
4703     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4704       int ret;
4705       long lpbytes;
4706       if (fd == 0) {
4707         ret = stdinAvailable(fd, &lpbytes);
4708       } else {
4709         ret = nonSeekAvailable(fd, &lpbytes);
4710       }
4711       (*bytes) = (jlong)(lpbytes);
4712       return ret;
4713     }
4714     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4715       return FALSE;
4716     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4717       return FALSE;
4718     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4719       return FALSE;
4720     }
4721     *bytes = end - cur;
4722     return TRUE;
4723   } else {
4724     return FALSE;
4725   }
4726 }
4727 
4728 void os::flockfile(FILE* fp) {
4729   _lock_file(fp);
4730 }
4731 
4732 void os::funlockfile(FILE* fp) {
4733   _unlock_file(fp);
4734 }
4735 
4736 // This code is a copy of JDK's nonSeekAvailable
4737 // from src/windows/hpi/src/sys_api_md.c
4738 
4739 static int nonSeekAvailable(int fd, long *pbytes) {
4740   // This is used for available on non-seekable devices
4741   // (like both named and anonymous pipes, such as pipes
4742   //  connected to an exec'd process).
4743   // Standard Input is a special case.
4744   HANDLE han;
4745 
4746   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4747     return FALSE;
4748   }
4749 
4750   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4751     // PeekNamedPipe fails when at EOF.  In that case we
4752     // simply make *pbytes = 0 which is consistent with the
4753     // behavior we get on Solaris when an fd is at EOF.
4754     // The only alternative is to raise an Exception,
4755     // which isn't really warranted.
4756     //
4757     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4758       return FALSE;
4759     }
4760     *pbytes = 0;
4761   }
4762   return TRUE;
4763 }
4764 
4765 #define MAX_INPUT_EVENTS 2000
4766 
4767 // This code is a copy of JDK's stdinAvailable
4768 // from src/windows/hpi/src/sys_api_md.c
4769 
4770 static int stdinAvailable(int fd, long *pbytes) {
4771   HANDLE han;
4772   DWORD numEventsRead = 0;  // Number of events read from buffer
4773   DWORD numEvents = 0;      // Number of events in buffer
4774   DWORD i = 0;              // Loop index
4775   DWORD curLength = 0;      // Position marker
4776   DWORD actualLength = 0;   // Number of bytes readable
4777   BOOL error = FALSE;       // Error holder
4778   INPUT_RECORD *lpBuffer;   // Pointer to records of input events
4779 
4780   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4781     return FALSE;
4782   }
4783 
4784   // Construct an array of input records in the console buffer
4785   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4786   if (error == 0) {
4787     return nonSeekAvailable(fd, pbytes);
4788   }
4789 
4790   // lpBuffer must fit into 64K or else PeekConsoleInput fails
4791   if (numEvents > MAX_INPUT_EVENTS) {
4792     numEvents = MAX_INPUT_EVENTS;
4793   }
4794 
4795   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4796   if (lpBuffer == NULL) {
4797     return FALSE;
4798   }
4799 
4800   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4801   if (error == 0) {
4802     os::free(lpBuffer);
4803     return FALSE;
4804   }
4805 
4806   // Examine input records for the number of bytes available
4807   for (i=0; i<numEvents; i++) {
4808     if (lpBuffer[i].EventType == KEY_EVENT) {
4809 
4810       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4811                                       &(lpBuffer[i].Event);
4812       if (keyRecord->bKeyDown == TRUE) {
4813         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4814         curLength++;
4815         if (*keyPressed == '\r') {
4816           actualLength = curLength;
4817         }
4818       }
4819     }
4820   }
4821 
4822   if (lpBuffer != NULL) {
4823     os::free(lpBuffer);
4824   }
4825 
4826   *pbytes = (long) actualLength;
4827   return TRUE;
4828 }
4829 
4830 // Map a block of memory.
4831 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4832                         char *addr, size_t bytes, bool read_only,
4833                         bool allow_exec) {
4834   HANDLE hFile;
4835   char* base;
4836 
4837   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4838                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4839   if (hFile == NULL) {
4840     log_info(os)("CreateFile() failed: GetLastError->%ld.", GetLastError());
4841     return NULL;
4842   }
4843 
4844   if (allow_exec) {
4845     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4846     // unless it comes from a PE image (which the shared archive is not.)
4847     // Even VirtualProtect refuses to give execute access to mapped memory
4848     // that was not previously executable.
4849     //
4850     // Instead, stick the executable region in anonymous memory.  Yuck.
4851     // Penalty is that ~4 pages will not be shareable - in the future
4852     // we might consider DLLizing the shared archive with a proper PE
4853     // header so that mapping executable + sharing is possible.
4854 
4855     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4856                                 PAGE_READWRITE);
4857     if (base == NULL) {
4858       log_info(os)("VirtualAlloc() failed: GetLastError->%ld.", GetLastError());
4859       CloseHandle(hFile);
4860       return NULL;
4861     }
4862 
4863     DWORD bytes_read;
4864     OVERLAPPED overlapped;
4865     overlapped.Offset = (DWORD)file_offset;
4866     overlapped.OffsetHigh = 0;
4867     overlapped.hEvent = NULL;
4868     // ReadFile guarantees that if the return value is true, the requested
4869     // number of bytes were read before returning.
4870     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4871     if (!res) {
4872       log_info(os)("ReadFile() failed: GetLastError->%ld.", GetLastError());
4873       release_memory(base, bytes);
4874       CloseHandle(hFile);
4875       return NULL;
4876     }
4877   } else {
4878     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4879                                     NULL /* file_name */);
4880     if (hMap == NULL) {
4881       log_info(os)("CreateFileMapping() failed: GetLastError->%ld.", GetLastError());
4882       CloseHandle(hFile);
4883       return NULL;
4884     }
4885 
4886     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4887     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4888                                   (DWORD)bytes, addr);
4889     if (base == NULL) {
4890       log_info(os)("MapViewOfFileEx() failed: GetLastError->%ld.", GetLastError());
4891       CloseHandle(hMap);
4892       CloseHandle(hFile);
4893       return NULL;
4894     }
4895 
4896     if (CloseHandle(hMap) == 0) {
4897       log_info(os)("CloseHandle(hMap) failed: GetLastError->%ld.", GetLastError());
4898       CloseHandle(hFile);
4899       return base;
4900     }
4901   }
4902 
4903   if (allow_exec) {
4904     DWORD old_protect;
4905     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4906     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4907 
4908     if (!res) {
4909       log_info(os)("VirtualProtect() failed: GetLastError->%ld.", GetLastError());
4910       // Don't consider this a hard error, on IA32 even if the
4911       // VirtualProtect fails, we should still be able to execute
4912       CloseHandle(hFile);
4913       return base;
4914     }
4915   }
4916 
4917   if (CloseHandle(hFile) == 0) {
4918     log_info(os)("CloseHandle(hFile) failed: GetLastError->%ld.", GetLastError());
4919     return base;
4920   }
4921 
4922   return base;
4923 }
4924 
4925 
4926 // Remap a block of memory.
4927 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4928                           char *addr, size_t bytes, bool read_only,
4929                           bool allow_exec) {
4930   // This OS does not allow existing memory maps to be remapped so we
4931   // have to unmap the memory before we remap it.
4932   if (!os::unmap_memory(addr, bytes)) {
4933     return NULL;
4934   }
4935 
4936   // There is a very small theoretical window between the unmap_memory()
4937   // call above and the map_memory() call below where a thread in native
4938   // code may be able to access an address that is no longer mapped.
4939 
4940   return os::map_memory(fd, file_name, file_offset, addr, bytes,
4941                         read_only, allow_exec);
4942 }
4943 
4944 
4945 // Unmap a block of memory.
4946 // Returns true=success, otherwise false.
4947 
4948 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4949   MEMORY_BASIC_INFORMATION mem_info;
4950   if (VirtualQuery(addr, &mem_info, sizeof(mem_info)) == 0) {
4951     log_info(os)("VirtualQuery() failed: GetLastError->%ld.", GetLastError());
4952     return false;
4953   }
4954 
4955   // Executable memory was not mapped using CreateFileMapping/MapViewOfFileEx.
4956   // Instead, executable region was allocated using VirtualAlloc(). See
4957   // pd_map_memory() above.
4958   //
4959   // The following flags should match the 'exec_access' flages used for
4960   // VirtualProtect() in pd_map_memory().
4961   if (mem_info.Protect == PAGE_EXECUTE_READ ||
4962       mem_info.Protect == PAGE_EXECUTE_READWRITE) {
4963     return pd_release_memory(addr, bytes);
4964   }
4965 
4966   BOOL result = UnmapViewOfFile(addr);
4967   if (result == 0) {
4968     log_info(os)("UnmapViewOfFile() failed: GetLastError->%ld.", GetLastError());
4969     return false;
4970   }
4971   return true;
4972 }
4973 
4974 void os::pause() {
4975   char filename[MAX_PATH];
4976   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4977     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4978   } else {
4979     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4980   }
4981 
4982   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4983   if (fd != -1) {
4984     struct stat buf;
4985     ::close(fd);
4986     while (::stat(filename, &buf) == 0) {
4987       Sleep(100);
4988     }
4989   } else {
4990     jio_fprintf(stderr,
4991                 "Could not open pause file '%s', continuing immediately.\n", filename);
4992   }
4993 }
4994 
4995 Thread* os::ThreadCrashProtection::_protected_thread = NULL;
4996 os::ThreadCrashProtection* os::ThreadCrashProtection::_crash_protection = NULL;
4997 volatile intptr_t os::ThreadCrashProtection::_crash_mux = 0;
4998 
4999 os::ThreadCrashProtection::ThreadCrashProtection() {
5000 }
5001 
5002 // See the caveats for this class in os_windows.hpp
5003 // Protects the callback call so that raised OS EXCEPTIONS causes a jump back
5004 // into this method and returns false. If no OS EXCEPTION was raised, returns
5005 // true.
5006 // The callback is supposed to provide the method that should be protected.
5007 //
5008 bool os::ThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
5009 
5010   Thread::muxAcquire(&_crash_mux, "CrashProtection");
5011 
5012   _protected_thread = Thread::current_or_null();
5013   assert(_protected_thread != NULL, "Cannot crash protect a NULL thread");
5014 
5015   bool success = true;
5016   __try {
5017     _crash_protection = this;
5018     cb.call();
5019   } __except(EXCEPTION_EXECUTE_HANDLER) {
5020     // only for protection, nothing to do
5021     success = false;
5022   }
5023   _crash_protection = NULL;
5024   _protected_thread = NULL;
5025   Thread::muxRelease(&_crash_mux);
5026   return success;
5027 }
5028 
5029 // An Event wraps a win32 "CreateEvent" kernel handle.
5030 //
5031 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
5032 //
5033 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
5034 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
5035 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
5036 //     In addition, an unpark() operation might fetch the handle field, but the
5037 //     event could recycle between the fetch and the SetEvent() operation.
5038 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
5039 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
5040 //     on an stale but recycled handle would be harmless, but in practice this might
5041 //     confuse other non-Sun code, so it's not a viable approach.
5042 //
5043 // 2:  Once a win32 event handle is associated with an Event, it remains associated
5044 //     with the Event.  The event handle is never closed.  This could be construed
5045 //     as handle leakage, but only up to the maximum # of threads that have been extant
5046 //     at any one time.  This shouldn't be an issue, as windows platforms typically
5047 //     permit a process to have hundreds of thousands of open handles.
5048 //
5049 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
5050 //     and release unused handles.
5051 //
5052 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
5053 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
5054 //
5055 // 5.  Use an RCU-like mechanism (Read-Copy Update).
5056 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
5057 //
5058 // We use (2).
5059 //
5060 // TODO-FIXME:
5061 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
5062 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
5063 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
5064 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
5065 //     into a single win32 CreateEvent() handle.
5066 //
5067 // Assumption:
5068 //    Only one parker can exist on an event, which is why we allocate
5069 //    them per-thread. Multiple unparkers can coexist.
5070 //
5071 // _Event transitions in park()
5072 //   -1 => -1 : illegal
5073 //    1 =>  0 : pass - return immediately
5074 //    0 => -1 : block; then set _Event to 0 before returning
5075 //
5076 // _Event transitions in unpark()
5077 //    0 => 1 : just return
5078 //    1 => 1 : just return
5079 //   -1 => either 0 or 1; must signal target thread
5080 //         That is, we can safely transition _Event from -1 to either
5081 //         0 or 1.
5082 //
5083 // _Event serves as a restricted-range semaphore.
5084 //   -1 : thread is blocked, i.e. there is a waiter
5085 //    0 : neutral: thread is running or ready,
5086 //        could have been signaled after a wait started
5087 //    1 : signaled - thread is running or ready
5088 //
5089 // Another possible encoding of _Event would be with
5090 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5091 //
5092 
5093 int os::PlatformEvent::park(jlong Millis) {
5094   // Transitions for _Event:
5095   //   -1 => -1 : illegal
5096   //    1 =>  0 : pass - return immediately
5097   //    0 => -1 : block; then set _Event to 0 before returning
5098 
5099   guarantee(_ParkHandle != NULL , "Invariant");
5100   guarantee(Millis > 0          , "Invariant");
5101 
5102   // CONSIDER: defer assigning a CreateEvent() handle to the Event until
5103   // the initial park() operation.
5104   // Consider: use atomic decrement instead of CAS-loop
5105 
5106   int v;
5107   for (;;) {
5108     v = _Event;
5109     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5110   }
5111   guarantee((v == 0) || (v == 1), "invariant");
5112   if (v != 0) return OS_OK;
5113 
5114   // Do this the hard way by blocking ...
5115   // TODO: consider a brief spin here, gated on the success of recent
5116   // spin attempts by this thread.
5117   //
5118   // We decompose long timeouts into series of shorter timed waits.
5119   // Evidently large timo values passed in WaitForSingleObject() are problematic on some
5120   // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
5121   // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
5122   // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
5123   // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
5124   // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
5125   // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
5126   // for the already waited time.  This policy does not admit any new outcomes.
5127   // In the future, however, we might want to track the accumulated wait time and
5128   // adjust Millis accordingly if we encounter a spurious wakeup.
5129 
5130   const int MAXTIMEOUT = 0x10000000;
5131   DWORD rv = WAIT_TIMEOUT;
5132   while (_Event < 0 && Millis > 0) {
5133     DWORD prd = Millis;     // set prd = MAX (Millis, MAXTIMEOUT)
5134     if (Millis > MAXTIMEOUT) {
5135       prd = MAXTIMEOUT;
5136     }
5137     rv = ::WaitForSingleObject(_ParkHandle, prd);
5138     assert(rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed");
5139     if (rv == WAIT_TIMEOUT) {
5140       Millis -= prd;
5141     }
5142   }
5143   v = _Event;
5144   _Event = 0;
5145   // see comment at end of os::PlatformEvent::park() below:
5146   OrderAccess::fence();
5147   // If we encounter a nearly simultanous timeout expiry and unpark()
5148   // we return OS_OK indicating we awoke via unpark().
5149   // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
5150   return (v >= 0) ? OS_OK : OS_TIMEOUT;
5151 }
5152 
5153 void os::PlatformEvent::park() {
5154   // Transitions for _Event:
5155   //   -1 => -1 : illegal
5156   //    1 =>  0 : pass - return immediately
5157   //    0 => -1 : block; then set _Event to 0 before returning
5158 
5159   guarantee(_ParkHandle != NULL, "Invariant");
5160   // Invariant: Only the thread associated with the Event/PlatformEvent
5161   // may call park().
5162   // Consider: use atomic decrement instead of CAS-loop
5163   int v;
5164   for (;;) {
5165     v = _Event;
5166     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5167   }
5168   guarantee((v == 0) || (v == 1), "invariant");
5169   if (v != 0) return;
5170 
5171   // Do this the hard way by blocking ...
5172   // TODO: consider a brief spin here, gated on the success of recent
5173   // spin attempts by this thread.
5174   while (_Event < 0) {
5175     DWORD rv = ::WaitForSingleObject(_ParkHandle, INFINITE);
5176     assert(rv == WAIT_OBJECT_0, "WaitForSingleObject failed");
5177   }
5178 
5179   // Usually we'll find _Event == 0 at this point, but as
5180   // an optional optimization we clear it, just in case can
5181   // multiple unpark() operations drove _Event up to 1.
5182   _Event = 0;
5183   OrderAccess::fence();
5184   guarantee(_Event >= 0, "invariant");
5185 }
5186 
5187 void os::PlatformEvent::unpark() {
5188   guarantee(_ParkHandle != NULL, "Invariant");
5189 
5190   // Transitions for _Event:
5191   //    0 => 1 : just return
5192   //    1 => 1 : just return
5193   //   -1 => either 0 or 1; must signal target thread
5194   //         That is, we can safely transition _Event from -1 to either
5195   //         0 or 1.
5196   // See also: "Semaphores in Plan 9" by Mullender & Cox
5197   //
5198   // Note: Forcing a transition from "-1" to "1" on an unpark() means
5199   // that it will take two back-to-back park() calls for the owning
5200   // thread to block. This has the benefit of forcing a spurious return
5201   // from the first park() call after an unpark() call which will help
5202   // shake out uses of park() and unpark() without condition variables.
5203 
5204   if (Atomic::xchg(1, &_Event) >= 0) return;
5205 
5206   ::SetEvent(_ParkHandle);
5207 }
5208 
5209 
5210 // JSR166
5211 // -------------------------------------------------------
5212 
5213 // The Windows implementation of Park is very straightforward: Basic
5214 // operations on Win32 Events turn out to have the right semantics to
5215 // use them directly. We opportunistically resuse the event inherited
5216 // from Monitor.
5217 
5218 void Parker::park(bool isAbsolute, jlong time) {
5219   guarantee(_ParkEvent != NULL, "invariant");
5220   // First, demultiplex/decode time arguments
5221   if (time < 0) { // don't wait
5222     return;
5223   } else if (time == 0 && !isAbsolute) {
5224     time = INFINITE;
5225   } else if (isAbsolute) {
5226     time -= os::javaTimeMillis(); // convert to relative time
5227     if (time <= 0) {  // already elapsed
5228       return;
5229     }
5230   } else { // relative
5231     time /= 1000000;  // Must coarsen from nanos to millis
5232     if (time == 0) {  // Wait for the minimal time unit if zero
5233       time = 1;
5234     }
5235   }
5236 
5237   JavaThread* thread = JavaThread::current();
5238 
5239   // Don't wait if interrupted or already triggered
5240   if (Thread::is_interrupted(thread, false) ||
5241       WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
5242     ResetEvent(_ParkEvent);
5243     return;
5244   } else {
5245     ThreadBlockInVM tbivm(thread);
5246     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5247     thread->set_suspend_equivalent();
5248 
5249     WaitForSingleObject(_ParkEvent, time);
5250     ResetEvent(_ParkEvent);
5251 
5252     // If externally suspended while waiting, re-suspend
5253     if (thread->handle_special_suspend_equivalent_condition()) {
5254       thread->java_suspend_self();
5255     }
5256   }
5257 }
5258 
5259 void Parker::unpark() {
5260   guarantee(_ParkEvent != NULL, "invariant");
5261   SetEvent(_ParkEvent);
5262 }
5263 
5264 // Run the specified command in a separate process. Return its exit value,
5265 // or -1 on failure (e.g. can't create a new process).
5266 int os::fork_and_exec(char* cmd) {
5267   STARTUPINFO si;
5268   PROCESS_INFORMATION pi;
5269   DWORD exit_code;
5270 
5271   char * cmd_string;
5272   char * cmd_prefix = "cmd /C ";
5273   size_t len = strlen(cmd) + strlen(cmd_prefix) + 1;
5274   cmd_string = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtInternal);
5275   if (cmd_string == NULL) {
5276     return -1;
5277   }
5278   cmd_string[0] = '\0';
5279   strcat(cmd_string, cmd_prefix);
5280   strcat(cmd_string, cmd);
5281 
5282   // now replace all '\n' with '&'
5283   char * substring = cmd_string;
5284   while ((substring = strchr(substring, '\n')) != NULL) {
5285     substring[0] = '&';
5286     substring++;
5287   }
5288   memset(&si, 0, sizeof(si));
5289   si.cb = sizeof(si);
5290   memset(&pi, 0, sizeof(pi));
5291   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
5292                             cmd_string,    // command line
5293                             NULL,   // process security attribute
5294                             NULL,   // thread security attribute
5295                             TRUE,   // inherits system handles
5296                             0,      // no creation flags
5297                             NULL,   // use parent's environment block
5298                             NULL,   // use parent's starting directory
5299                             &si,    // (in) startup information
5300                             &pi);   // (out) process information
5301 
5302   if (rslt) {
5303     // Wait until child process exits.
5304     WaitForSingleObject(pi.hProcess, INFINITE);
5305 
5306     GetExitCodeProcess(pi.hProcess, &exit_code);
5307 
5308     // Close process and thread handles.
5309     CloseHandle(pi.hProcess);
5310     CloseHandle(pi.hThread);
5311   } else {
5312     exit_code = -1;
5313   }
5314 
5315   FREE_C_HEAP_ARRAY(char, cmd_string);
5316   return (int)exit_code;
5317 }
5318 
5319 bool os::find(address addr, outputStream* st) {
5320   int offset = -1;
5321   bool result = false;
5322   char buf[256];
5323   if (os::dll_address_to_library_name(addr, buf, sizeof(buf), &offset)) {
5324     st->print(PTR_FORMAT " ", addr);
5325     if (strlen(buf) < sizeof(buf) - 1) {
5326       char* p = strrchr(buf, '\\');
5327       if (p) {
5328         st->print("%s", p + 1);
5329       } else {
5330         st->print("%s", buf);
5331       }
5332     } else {
5333         // The library name is probably truncated. Let's omit the library name.
5334         // See also JDK-8147512.
5335     }
5336     if (os::dll_address_to_function_name(addr, buf, sizeof(buf), &offset)) {
5337       st->print("::%s + 0x%x", buf, offset);
5338     }
5339     st->cr();
5340     result = true;
5341   }
5342   return result;
5343 }
5344 
5345 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5346   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5347 
5348   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
5349     JavaThread* thread = JavaThread::current();
5350     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5351     address addr = (address) exceptionRecord->ExceptionInformation[1];
5352 
5353     if (os::is_memory_serialize_page(thread, addr)) {
5354       return EXCEPTION_CONTINUE_EXECUTION;
5355     }
5356   }
5357 
5358   return EXCEPTION_CONTINUE_SEARCH;
5359 }
5360 
5361 static jint initSock() {
5362   WSADATA wsadata;
5363 
5364   if (WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5365     jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5366                 ::GetLastError());
5367     return JNI_ERR;
5368   }
5369   return JNI_OK;
5370 }
5371 
5372 struct hostent* os::get_host_by_name(char* name) {
5373   return (struct hostent*)gethostbyname(name);
5374 }
5375 
5376 int os::socket_close(int fd) {
5377   return ::closesocket(fd);
5378 }
5379 
5380 int os::socket(int domain, int type, int protocol) {
5381   return ::socket(domain, type, protocol);
5382 }
5383 
5384 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5385   return ::connect(fd, him, len);
5386 }
5387 
5388 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5389   return ::recv(fd, buf, (int)nBytes, flags);
5390 }
5391 
5392 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5393   return ::send(fd, buf, (int)nBytes, flags);
5394 }
5395 
5396 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5397   return ::send(fd, buf, (int)nBytes, flags);
5398 }
5399 
5400 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5401 #if defined(IA32)
5402   #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5403 #elif defined (AMD64)
5404   #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5405 #endif
5406 
5407 // returns true if thread could be suspended,
5408 // false otherwise
5409 static bool do_suspend(HANDLE* h) {
5410   if (h != NULL) {
5411     if (SuspendThread(*h) != ~0) {
5412       return true;
5413     }
5414   }
5415   return false;
5416 }
5417 
5418 // resume the thread
5419 // calling resume on an active thread is a no-op
5420 static void do_resume(HANDLE* h) {
5421   if (h != NULL) {
5422     ResumeThread(*h);
5423   }
5424 }
5425 
5426 // retrieve a suspend/resume context capable handle
5427 // from the tid. Caller validates handle return value.
5428 void get_thread_handle_for_extended_context(HANDLE* h,
5429                                             OSThread::thread_id_t tid) {
5430   if (h != NULL) {
5431     *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5432   }
5433 }
5434 
5435 // Thread sampling implementation
5436 //
5437 void os::SuspendedThreadTask::internal_do_task() {
5438   CONTEXT    ctxt;
5439   HANDLE     h = NULL;
5440 
5441   // get context capable handle for thread
5442   get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5443 
5444   // sanity
5445   if (h == NULL || h == INVALID_HANDLE_VALUE) {
5446     return;
5447   }
5448 
5449   // suspend the thread
5450   if (do_suspend(&h)) {
5451     ctxt.ContextFlags = sampling_context_flags;
5452     // get thread context
5453     GetThreadContext(h, &ctxt);
5454     SuspendedThreadTaskContext context(_thread, &ctxt);
5455     // pass context to Thread Sampling impl
5456     do_task(context);
5457     // resume thread
5458     do_resume(&h);
5459   }
5460 
5461   // close handle
5462   CloseHandle(h);
5463 }
5464 
5465 bool os::start_debugging(char *buf, int buflen) {
5466   int len = (int)strlen(buf);
5467   char *p = &buf[len];
5468 
5469   jio_snprintf(p, buflen-len,
5470              "\n\n"
5471              "Do you want to debug the problem?\n\n"
5472              "To debug, attach Visual Studio to process %d; then switch to thread 0x%x\n"
5473              "Select 'Yes' to launch Visual Studio automatically (PATH must include msdev)\n"
5474              "Otherwise, select 'No' to abort...",
5475              os::current_process_id(), os::current_thread_id());
5476 
5477   bool yes = os::message_box("Unexpected Error", buf);
5478 
5479   if (yes) {
5480     // os::breakpoint() calls DebugBreak(), which causes a breakpoint
5481     // exception. If VM is running inside a debugger, the debugger will
5482     // catch the exception. Otherwise, the breakpoint exception will reach
5483     // the default windows exception handler, which can spawn a debugger and
5484     // automatically attach to the dying VM.
5485     os::breakpoint();
5486     yes = false;
5487   }
5488   return yes;
5489 }
5490 
5491 void* os::get_default_process_handle() {
5492   return (void*)GetModuleHandle(NULL);
5493 }
5494 
5495 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
5496 // which is used to find statically linked in agents.
5497 // Additionally for windows, takes into account __stdcall names.
5498 // Parameters:
5499 //            sym_name: Symbol in library we are looking for
5500 //            lib_name: Name of library to look in, NULL for shared libs.
5501 //            is_absolute_path == true if lib_name is absolute path to agent
5502 //                                     such as "C:/a/b/L.dll"
5503 //            == false if only the base name of the library is passed in
5504 //               such as "L"
5505 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
5506                                     bool is_absolute_path) {
5507   char *agent_entry_name;
5508   size_t len;
5509   size_t name_len;
5510   size_t prefix_len = strlen(JNI_LIB_PREFIX);
5511   size_t suffix_len = strlen(JNI_LIB_SUFFIX);
5512   const char *start;
5513 
5514   if (lib_name != NULL) {
5515     len = name_len = strlen(lib_name);
5516     if (is_absolute_path) {
5517       // Need to strip path, prefix and suffix
5518       if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
5519         lib_name = ++start;
5520       } else {
5521         // Need to check for drive prefix
5522         if ((start = strchr(lib_name, ':')) != NULL) {
5523           lib_name = ++start;
5524         }
5525       }
5526       if (len <= (prefix_len + suffix_len)) {
5527         return NULL;
5528       }
5529       lib_name += prefix_len;
5530       name_len = strlen(lib_name) - suffix_len;
5531     }
5532   }
5533   len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
5534   agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
5535   if (agent_entry_name == NULL) {
5536     return NULL;
5537   }
5538   if (lib_name != NULL) {
5539     const char *p = strrchr(sym_name, '@');
5540     if (p != NULL && p != sym_name) {
5541       // sym_name == _Agent_OnLoad@XX
5542       strncpy(agent_entry_name, sym_name, (p - sym_name));
5543       agent_entry_name[(p-sym_name)] = '\0';
5544       // agent_entry_name == _Agent_OnLoad
5545       strcat(agent_entry_name, "_");
5546       strncat(agent_entry_name, lib_name, name_len);
5547       strcat(agent_entry_name, p);
5548       // agent_entry_name == _Agent_OnLoad_lib_name@XX
5549     } else {
5550       strcpy(agent_entry_name, sym_name);
5551       strcat(agent_entry_name, "_");
5552       strncat(agent_entry_name, lib_name, name_len);
5553     }
5554   } else {
5555     strcpy(agent_entry_name, sym_name);
5556   }
5557   return agent_entry_name;
5558 }
5559 
5560 #ifndef PRODUCT
5561 
5562 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5563 // contiguous memory block at a particular address.
5564 // The test first tries to find a good approximate address to allocate at by using the same
5565 // method to allocate some memory at any address. The test then tries to allocate memory in
5566 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5567 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5568 // the previously allocated memory is available for allocation. The only actual failure
5569 // that is reported is when the test tries to allocate at a particular location but gets a
5570 // different valid one. A NULL return value at this point is not considered an error but may
5571 // be legitimate.
5572 // If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages.
5573 void TestReserveMemorySpecial_test() {
5574   if (!UseLargePages) {
5575     if (VerboseInternalVMTests) {
5576       tty->print("Skipping test because large pages are disabled");
5577     }
5578     return;
5579   }
5580   // save current value of globals
5581   bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5582   bool old_use_numa_interleaving = UseNUMAInterleaving;
5583 
5584   // set globals to make sure we hit the correct code path
5585   UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5586 
5587   // do an allocation at an address selected by the OS to get a good one.
5588   const size_t large_allocation_size = os::large_page_size() * 4;
5589   char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5590   if (result == NULL) {
5591     if (VerboseInternalVMTests) {
5592       tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
5593                           large_allocation_size);
5594     }
5595   } else {
5596     os::release_memory_special(result, large_allocation_size);
5597 
5598     // allocate another page within the recently allocated memory area which seems to be a good location. At least
5599     // we managed to get it once.
5600     const size_t expected_allocation_size = os::large_page_size();
5601     char* expected_location = result + os::large_page_size();
5602     char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5603     if (actual_location == NULL) {
5604       if (VerboseInternalVMTests) {
5605         tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
5606                             expected_location, large_allocation_size);
5607       }
5608     } else {
5609       // release memory
5610       os::release_memory_special(actual_location, expected_allocation_size);
5611       // only now check, after releasing any memory to avoid any leaks.
5612       assert(actual_location == expected_location,
5613              "Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
5614              expected_location, expected_allocation_size, actual_location);
5615     }
5616   }
5617 
5618   // restore globals
5619   UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5620   UseNUMAInterleaving = old_use_numa_interleaving;
5621 }
5622 #endif // PRODUCT
5623 
5624 /*
5625   All the defined signal names for Windows.
5626 
5627   NOTE that not all of these names are accepted by FindSignal!
5628 
5629   For various reasons some of these may be rejected at runtime.
5630 
5631   Here are the names currently accepted by a user of sun.misc.Signal with
5632   1.4.1 (ignoring potential interaction with use of chaining, etc):
5633 
5634      (LIST TBD)
5635 
5636 */
5637 int os::get_signal_number(const char* name) {
5638   static const struct {
5639     char* name;
5640     int   number;
5641   } siglabels [] =
5642     // derived from version 6.0 VC98/include/signal.h
5643   {"ABRT",      SIGABRT,        // abnormal termination triggered by abort cl
5644   "FPE",        SIGFPE,         // floating point exception
5645   "SEGV",       SIGSEGV,        // segment violation
5646   "INT",        SIGINT,         // interrupt
5647   "TERM",       SIGTERM,        // software term signal from kill
5648   "BREAK",      SIGBREAK,       // Ctrl-Break sequence
5649   "ILL",        SIGILL};        // illegal instruction
5650   for (unsigned i = 0; i < ARRAY_SIZE(siglabels); ++i) {
5651     if (strcmp(name, siglabels[i].name) == 0) {
5652       return siglabels[i].number;
5653     }
5654   }
5655   return -1;
5656 }
5657 
5658 // Fast current thread access
5659 
5660 int os::win32::_thread_ptr_offset = 0;
5661 
5662 static void call_wrapper_dummy() {}
5663 
5664 // We need to call the os_exception_wrapper once so that it sets
5665 // up the offset from FS of the thread pointer.
5666 void os::win32::initialize_thread_ptr_offset() {
5667   os::os_exception_wrapper((java_call_t)call_wrapper_dummy,
5668                            NULL, NULL, NULL, NULL);
5669 }