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