rev 59057 : imported patch fix

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