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 int os::get_loaded_modules_info(os::LoadedModulesCallbackFunc callback, void *param) {
1673   HANDLE   hProcess;
1674 
1675 # define MAX_NUM_MODULES 128
1676   HMODULE     modules[MAX_NUM_MODULES];
1677   static char filename[MAX_PATH];
1678   int         result = 0;
1679 
1680   int pid = os::current_process_id();
1681   hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
1682                          FALSE, pid);
1683   if (hProcess == NULL) return 0;
1684 
1685   DWORD size_needed;
1686   if (!EnumProcessModules(hProcess, modules, sizeof(modules), &size_needed)) {
1687     CloseHandle(hProcess);
1688     return 0;
1689   }
1690 
1691   // number of modules that are currently loaded
1692   int num_modules = size_needed / sizeof(HMODULE);
1693 
1694   for (int i = 0; i < MIN2(num_modules, MAX_NUM_MODULES); i++) {
1695     // Get Full pathname:
1696     if (!GetModuleFileNameEx(hProcess, modules[i], filename, sizeof(filename))) {
1697       filename[0] = '\0';
1698     }
1699 
1700     MODULEINFO modinfo;
1701     if (!GetModuleInformation(hProcess, modules[i], &modinfo, sizeof(modinfo))) {
1702       modinfo.lpBaseOfDll = NULL;
1703       modinfo.SizeOfImage = 0;
1704     }
1705 
1706     // Invoke callback function
1707     result = callback(filename, (address)modinfo.lpBaseOfDll,
1708                       (address)((u8)modinfo.lpBaseOfDll + (u8)modinfo.SizeOfImage), param);
1709     if (result) break;
1710   }
1711 
1712   CloseHandle(hProcess);
1713   return result;
1714 }
1715 
1716 void os::print_os_info_brief(outputStream* st) {
1717   os::print_os_info(st);
1718 }
1719 
1720 void os::print_os_info(outputStream* st) {
1721   st->print("OS:");
1722 
1723   os::win32::print_windows_version(st);
1724 }
1725 
1726 void os::win32::print_windows_version(outputStream* st) {
1727   OSVERSIONINFOEX osvi;
1728   VS_FIXEDFILEINFO *file_info;
1729   TCHAR kernel32_path[MAX_PATH];
1730   UINT len, ret;
1731 
1732   // Use the GetVersionEx information to see if we're on a server or
1733   // workstation edition of Windows. Starting with Windows 8.1 we can't
1734   // trust the OS version information returned by this API.
1735   ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
1736   osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
1737   if (!GetVersionEx((OSVERSIONINFO *)&osvi)) {
1738     st->print_cr("Call to GetVersionEx failed");
1739     return;
1740   }
1741   bool is_workstation = (osvi.wProductType == VER_NT_WORKSTATION);
1742 
1743   // Get the full path to \Windows\System32\kernel32.dll and use that for
1744   // determining what version of Windows we're running on.
1745   len = MAX_PATH - (UINT)strlen("\\kernel32.dll") - 1;
1746   ret = GetSystemDirectory(kernel32_path, len);
1747   if (ret == 0 || ret > len) {
1748     st->print_cr("Call to GetSystemDirectory failed");
1749     return;
1750   }
1751   strncat(kernel32_path, "\\kernel32.dll", MAX_PATH - ret);
1752 
1753   DWORD version_size = GetFileVersionInfoSize(kernel32_path, NULL);
1754   if (version_size == 0) {
1755     st->print_cr("Call to GetFileVersionInfoSize failed");
1756     return;
1757   }
1758 
1759   LPTSTR version_info = (LPTSTR)os::malloc(version_size, mtInternal);
1760   if (version_info == NULL) {
1761     st->print_cr("Failed to allocate version_info");
1762     return;
1763   }
1764 
1765   if (!GetFileVersionInfo(kernel32_path, NULL, version_size, version_info)) {
1766     os::free(version_info);
1767     st->print_cr("Call to GetFileVersionInfo failed");
1768     return;
1769   }
1770 
1771   if (!VerQueryValue(version_info, TEXT("\\"), (LPVOID*)&file_info, &len)) {
1772     os::free(version_info);
1773     st->print_cr("Call to VerQueryValue failed");
1774     return;
1775   }
1776 
1777   int major_version = HIWORD(file_info->dwProductVersionMS);
1778   int minor_version = LOWORD(file_info->dwProductVersionMS);
1779   int build_number = HIWORD(file_info->dwProductVersionLS);
1780   int build_minor = LOWORD(file_info->dwProductVersionLS);
1781   int os_vers = major_version * 1000 + minor_version;
1782   os::free(version_info);
1783 
1784   st->print(" Windows ");
1785   switch (os_vers) {
1786 
1787   case 6000:
1788     if (is_workstation) {
1789       st->print("Vista");
1790     } else {
1791       st->print("Server 2008");
1792     }
1793     break;
1794 
1795   case 6001:
1796     if (is_workstation) {
1797       st->print("7");
1798     } else {
1799       st->print("Server 2008 R2");
1800     }
1801     break;
1802 
1803   case 6002:
1804     if (is_workstation) {
1805       st->print("8");
1806     } else {
1807       st->print("Server 2012");
1808     }
1809     break;
1810 
1811   case 6003:
1812     if (is_workstation) {
1813       st->print("8.1");
1814     } else {
1815       st->print("Server 2012 R2");
1816     }
1817     break;
1818 
1819   case 6004:
1820     if (is_workstation) {
1821       st->print("10");
1822     } else {
1823       // distinguish Windows Server 2016 and 2019 by build number
1824       // Windows server 2019 GA 10/2018 build number is 17763
1825       if (build_number > 17762) {
1826         st->print("Server 2019");
1827       } else {
1828         st->print("Server 2016");
1829       }
1830     }
1831     break;
1832 
1833   default:
1834     // Unrecognized windows, print out its major and minor versions
1835     st->print("%d.%d", major_version, minor_version);
1836     break;
1837   }
1838 
1839   // Retrieve SYSTEM_INFO from GetNativeSystemInfo call so that we could
1840   // find out whether we are running on 64 bit processor or not
1841   SYSTEM_INFO si;
1842   ZeroMemory(&si, sizeof(SYSTEM_INFO));
1843   os::Kernel32Dll::GetNativeSystemInfo(&si);
1844   if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
1845     st->print(" , 64 bit");
1846   }
1847 
1848   st->print(" Build %d", build_number);
1849   st->print(" (%d.%d.%d.%d)", major_version, minor_version, build_number, build_minor);
1850   st->cr();
1851 }
1852 
1853 void os::pd_print_cpu_info(outputStream* st) {
1854   // Nothing to do for now.
1855 }
1856 
1857 void os::print_memory_info(outputStream* st) {
1858   st->print("Memory:");
1859   st->print(" %dk page", os::vm_page_size()>>10);
1860 
1861   // Use GlobalMemoryStatusEx() because GlobalMemoryStatus() may return incorrect
1862   // value if total memory is larger than 4GB
1863   MEMORYSTATUSEX ms;
1864   ms.dwLength = sizeof(ms);
1865   GlobalMemoryStatusEx(&ms);
1866 
1867   st->print(", physical %uk", os::physical_memory() >> 10);
1868   st->print("(%uk free)", os::available_memory() >> 10);
1869 
1870   st->print(", swap %uk", ms.ullTotalPageFile >> 10);
1871   st->print("(%uk free)", ms.ullAvailPageFile >> 10);
1872   st->cr();
1873 }
1874 
1875 void os::print_siginfo(outputStream *st, void *siginfo) {
1876   EXCEPTION_RECORD* er = (EXCEPTION_RECORD*)siginfo;
1877   st->print("siginfo:");
1878   st->print(" ExceptionCode=0x%x", er->ExceptionCode);
1879 
1880   if (er->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
1881       er->NumberParameters >= 2) {
1882       switch (er->ExceptionInformation[0]) {
1883       case 0: st->print(", reading address"); break;
1884       case 1: st->print(", writing address"); break;
1885       default: st->print(", ExceptionInformation=" INTPTR_FORMAT,
1886                             er->ExceptionInformation[0]);
1887       }
1888       st->print(" " INTPTR_FORMAT, er->ExceptionInformation[1]);
1889   } else if (er->ExceptionCode == EXCEPTION_IN_PAGE_ERROR &&
1890              er->NumberParameters >= 2 && UseSharedSpaces) {
1891     FileMapInfo* mapinfo = FileMapInfo::current_info();
1892     if (mapinfo->is_in_shared_space((void*)er->ExceptionInformation[1])) {
1893       st->print("\n\nError accessing class data sharing archive."       \
1894                 " Mapped file inaccessible during execution, "          \
1895                 " possible disk/network problem.");
1896     }
1897   } else {
1898     int num = er->NumberParameters;
1899     if (num > 0) {
1900       st->print(", ExceptionInformation=");
1901       for (int i = 0; i < num; i++) {
1902         st->print(INTPTR_FORMAT " ", er->ExceptionInformation[i]);
1903       }
1904     }
1905   }
1906   st->cr();
1907 }
1908 
1909 
1910 int os::vsnprintf(char* buf, size_t len, const char* fmt, va_list args) {
1911 #if _MSC_VER >= 1900
1912   // Starting with Visual Studio 2015, vsnprint is C99 compliant.
1913   int result = ::vsnprintf(buf, len, fmt, args);
1914   // If an encoding error occurred (result < 0) then it's not clear
1915   // whether the buffer is NUL terminated, so ensure it is.
1916   if ((result < 0) && (len > 0)) {
1917     buf[len - 1] = '\0';
1918   }
1919   return result;
1920 #else
1921   // Before Visual Studio 2015, vsnprintf is not C99 compliant, so use
1922   // _vsnprintf, whose behavior seems to be *mostly* consistent across
1923   // versions.  However, when len == 0, avoid _vsnprintf too, and just
1924   // go straight to _vscprintf.  The output is going to be truncated in
1925   // that case, except in the unusual case of empty output.  More
1926   // importantly, the documentation for various versions of Visual Studio
1927   // are inconsistent about the behavior of _vsnprintf when len == 0,
1928   // including it possibly being an error.
1929   int result = -1;
1930   if (len > 0) {
1931     result = _vsnprintf(buf, len, fmt, args);
1932     // If output (including NUL terminator) is truncated, the buffer
1933     // won't be NUL terminated.  Add the trailing NUL specified by C99.
1934     if ((result < 0) || (result >= (int) len)) {
1935       buf[len - 1] = '\0';
1936     }
1937   }
1938   if (result < 0) {
1939     result = _vscprintf(fmt, args);
1940   }
1941   return result;
1942 #endif // _MSC_VER dispatch
1943 }
1944 
1945 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1946   // do nothing
1947 }
1948 
1949 static char saved_jvm_path[MAX_PATH] = {0};
1950 
1951 // Find the full path to the current module, jvm.dll
1952 void os::jvm_path(char *buf, jint buflen) {
1953   // Error checking.
1954   if (buflen < MAX_PATH) {
1955     assert(false, "must use a large-enough buffer");
1956     buf[0] = '\0';
1957     return;
1958   }
1959   // Lazy resolve the path to current module.
1960   if (saved_jvm_path[0] != 0) {
1961     strcpy(buf, saved_jvm_path);
1962     return;
1963   }
1964 
1965   buf[0] = '\0';
1966   if (Arguments::created_by_gamma_launcher()) {
1967      // Support for the gamma launcher. Check for an
1968      // JAVA_HOME environment variable
1969      // and fix up the path so it looks like
1970      // libjvm.so is installed there (append a fake suffix
1971      // hotspot/libjvm.so).
1972      char* java_home_var = ::getenv("JAVA_HOME");
1973      if (java_home_var != NULL && java_home_var[0] != 0 &&
1974          strlen(java_home_var) < (size_t)buflen) {
1975 
1976         strncpy(buf, java_home_var, buflen);
1977 
1978         // determine if this is a legacy image or modules image
1979         // modules image doesn't have "jre" subdirectory
1980         size_t len = strlen(buf);
1981         char* jrebin_p = buf + len;
1982         jio_snprintf(jrebin_p, buflen-len, "\\jre\\bin\\");
1983         if (0 != _access(buf, 0)) {
1984           jio_snprintf(jrebin_p, buflen-len, "\\bin\\");
1985         }
1986         len = strlen(buf);
1987         jio_snprintf(buf + len, buflen-len, "hotspot\\jvm.dll");
1988      }
1989   }
1990 
1991   if(buf[0] == '\0') {
1992     GetModuleFileName(vm_lib_handle, buf, buflen);
1993   }
1994   strncpy(saved_jvm_path, buf, MAX_PATH);
1995 }
1996 
1997 
1998 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1999 #ifndef _WIN64
2000   st->print("_");
2001 #endif
2002 }
2003 
2004 
2005 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2006 #ifndef _WIN64
2007   st->print("@%d", args_size  * sizeof(int));
2008 #endif
2009 }
2010 
2011 // This method is a copy of JDK's sysGetLastErrorString
2012 // from src/windows/hpi/src/system_md.c
2013 
2014 size_t os::lasterror(char* buf, size_t len) {
2015   DWORD errval;
2016 
2017   if ((errval = GetLastError()) != 0) {
2018     // DOS error
2019     size_t n = (size_t)FormatMessage(
2020           FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
2021           NULL,
2022           errval,
2023           0,
2024           buf,
2025           (DWORD)len,
2026           NULL);
2027     if (n > 3) {
2028       // Drop final '.', CR, LF
2029       if (buf[n - 1] == '\n') n--;
2030       if (buf[n - 1] == '\r') n--;
2031       if (buf[n - 1] == '.') n--;
2032       buf[n] = '\0';
2033     }
2034     return n;
2035   }
2036 
2037   if (errno != 0) {
2038     // C runtime error that has no corresponding DOS error code
2039     const char* s = strerror(errno);
2040     size_t n = strlen(s);
2041     if (n >= len) n = len - 1;
2042     strncpy(buf, s, n);
2043     buf[n] = '\0';
2044     return n;
2045   }
2046 
2047   return 0;
2048 }
2049 
2050 int os::get_last_error() {
2051   DWORD error = GetLastError();
2052   if (error == 0)
2053     error = errno;
2054   return (int)error;
2055 }
2056 
2057 // sun.misc.Signal
2058 // NOTE that this is a workaround for an apparent kernel bug where if
2059 // a signal handler for SIGBREAK is installed then that signal handler
2060 // takes priority over the console control handler for CTRL_CLOSE_EVENT.
2061 // See bug 4416763.
2062 static void (*sigbreakHandler)(int) = NULL;
2063 
2064 static void UserHandler(int sig, void *siginfo, void *context) {
2065   os::signal_notify(sig);
2066   // We need to reinstate the signal handler each time...
2067   os::signal(sig, (void*)UserHandler);
2068 }
2069 
2070 void* os::user_handler() {
2071   return (void*) UserHandler;
2072 }
2073 
2074 void* os::signal(int signal_number, void* handler) {
2075   if ((signal_number == SIGBREAK) && (!ReduceSignalUsage)) {
2076     void (*oldHandler)(int) = sigbreakHandler;
2077     sigbreakHandler = (void (*)(int)) handler;
2078     return (void*) oldHandler;
2079   } else {
2080     return (void*)::signal(signal_number, (void (*)(int))handler);
2081   }
2082 }
2083 
2084 void os::signal_raise(int signal_number) {
2085   raise(signal_number);
2086 }
2087 
2088 // The Win32 C runtime library maps all console control events other than ^C
2089 // into SIGBREAK, which makes it impossible to distinguish ^BREAK from close,
2090 // logoff, and shutdown events.  We therefore install our own console handler
2091 // that raises SIGTERM for the latter cases.
2092 //
2093 static BOOL WINAPI consoleHandler(DWORD event) {
2094   switch(event) {
2095     case CTRL_C_EVENT:
2096       if (is_error_reported()) {
2097         // Ctrl-C is pressed during error reporting, likely because the error
2098         // handler fails to abort. Let VM die immediately.
2099         os::die();
2100       }
2101 
2102       os::signal_raise(SIGINT);
2103       return TRUE;
2104       break;
2105     case CTRL_BREAK_EVENT:
2106       if (sigbreakHandler != NULL) {
2107         (*sigbreakHandler)(SIGBREAK);
2108       }
2109       return TRUE;
2110       break;
2111     case CTRL_LOGOFF_EVENT: {
2112       // Don't terminate JVM if it is running in a non-interactive session,
2113       // such as a service process.
2114       USEROBJECTFLAGS flags;
2115       HANDLE handle = GetProcessWindowStation();
2116       if (handle != NULL &&
2117           GetUserObjectInformation(handle, UOI_FLAGS, &flags,
2118             sizeof( USEROBJECTFLAGS), NULL)) {
2119         // If it is a non-interactive session, let next handler to deal
2120         // with it.
2121         if ((flags.dwFlags & WSF_VISIBLE) == 0) {
2122           return FALSE;
2123         }
2124       }
2125     }
2126     case CTRL_CLOSE_EVENT:
2127     case CTRL_SHUTDOWN_EVENT:
2128       os::signal_raise(SIGTERM);
2129       return TRUE;
2130       break;
2131     default:
2132       break;
2133   }
2134   return FALSE;
2135 }
2136 
2137 /*
2138  * The following code is moved from os.cpp for making this
2139  * code platform specific, which it is by its very nature.
2140  */
2141 
2142 // Return maximum OS signal used + 1 for internal use only
2143 // Used as exit signal for signal_thread
2144 int os::sigexitnum_pd(){
2145   return NSIG;
2146 }
2147 
2148 // a counter for each possible signal value, including signal_thread exit signal
2149 static volatile jint pending_signals[NSIG+1] = { 0 };
2150 static HANDLE sig_sem = NULL;
2151 
2152 void os::signal_init_pd() {
2153   // Initialize signal structures
2154   memset((void*)pending_signals, 0, sizeof(pending_signals));
2155 
2156   sig_sem = ::CreateSemaphore(NULL, 0, NSIG+1, NULL);
2157 
2158   // Programs embedding the VM do not want it to attempt to receive
2159   // events like CTRL_LOGOFF_EVENT, which are used to implement the
2160   // shutdown hooks mechanism introduced in 1.3.  For example, when
2161   // the VM is run as part of a Windows NT service (i.e., a servlet
2162   // engine in a web server), the correct behavior is for any console
2163   // control handler to return FALSE, not TRUE, because the OS's
2164   // "final" handler for such events allows the process to continue if
2165   // it is a service (while terminating it if it is not a service).
2166   // To make this behavior uniform and the mechanism simpler, we
2167   // completely disable the VM's usage of these console events if -Xrs
2168   // (=ReduceSignalUsage) is specified.  This means, for example, that
2169   // the CTRL-BREAK thread dump mechanism is also disabled in this
2170   // case.  See bugs 4323062, 4345157, and related bugs.
2171 
2172   if (!ReduceSignalUsage) {
2173     // Add a CTRL-C handler
2174     SetConsoleCtrlHandler(consoleHandler, TRUE);
2175   }
2176 }
2177 
2178 void os::signal_notify(int signal_number) {
2179   BOOL ret;
2180   if (sig_sem != NULL) {
2181     Atomic::inc(&pending_signals[signal_number]);
2182     ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2183     assert(ret != 0, "ReleaseSemaphore() failed");
2184   }
2185 }
2186 
2187 static int check_pending_signals(bool wait_for_signal) {
2188   DWORD ret;
2189   while (true) {
2190     for (int i = 0; i < NSIG + 1; i++) {
2191       jint n = pending_signals[i];
2192       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2193         return i;
2194       }
2195     }
2196     if (!wait_for_signal) {
2197       return -1;
2198     }
2199 
2200     JavaThread *thread = JavaThread::current();
2201 
2202     ThreadBlockInVM tbivm(thread);
2203 
2204     bool threadIsSuspended;
2205     do {
2206       thread->set_suspend_equivalent();
2207       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2208       ret = ::WaitForSingleObject(sig_sem, INFINITE);
2209       assert(ret == WAIT_OBJECT_0, "WaitForSingleObject() failed");
2210 
2211       // were we externally suspended while we were waiting?
2212       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2213       if (threadIsSuspended) {
2214         //
2215         // The semaphore has been incremented, but while we were waiting
2216         // another thread suspended us. We don't want to continue running
2217         // while suspended because that would surprise the thread that
2218         // suspended us.
2219         //
2220         ret = ::ReleaseSemaphore(sig_sem, 1, NULL);
2221         assert(ret != 0, "ReleaseSemaphore() failed");
2222 
2223         thread->java_suspend_self();
2224       }
2225     } while (threadIsSuspended);
2226   }
2227 }
2228 
2229 int os::signal_lookup() {
2230   return check_pending_signals(false);
2231 }
2232 
2233 int os::signal_wait() {
2234   return check_pending_signals(true);
2235 }
2236 
2237 // Implicit OS exception handling
2238 
2239 LONG Handle_Exception(struct _EXCEPTION_POINTERS* exceptionInfo, address handler) {
2240   JavaThread* thread = JavaThread::current();
2241   // Save pc in thread
2242 #ifdef _M_IA64
2243   // Do not blow up if no thread info available.
2244   if (thread) {
2245     // Saving PRECISE pc (with slot information) in thread.
2246     uint64_t precise_pc = (uint64_t) exceptionInfo->ExceptionRecord->ExceptionAddress;
2247     // Convert precise PC into "Unix" format
2248     precise_pc = (precise_pc & 0xFFFFFFFFFFFFFFF0) | ((precise_pc & 0xF) >> 2);
2249     thread->set_saved_exception_pc((address)precise_pc);
2250   }
2251   // Set pc to handler
2252   exceptionInfo->ContextRecord->StIIP = (DWORD64)handler;
2253   // Clear out psr.ri (= Restart Instruction) in order to continue
2254   // at the beginning of the target bundle.
2255   exceptionInfo->ContextRecord->StIPSR &= 0xFFFFF9FFFFFFFFFF;
2256   assert(((DWORD64)handler & 0xF) == 0, "Target address must point to the beginning of a bundle!");
2257 #else
2258   #ifdef _M_AMD64
2259   // Do not blow up if no thread info available.
2260   if (thread) {
2261     thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Rip);
2262   }
2263   // Set pc to handler
2264   exceptionInfo->ContextRecord->Rip = (DWORD64)handler;
2265   #else
2266   // Do not blow up if no thread info available.
2267   if (thread) {
2268     thread->set_saved_exception_pc((address)(DWORD_PTR)exceptionInfo->ContextRecord->Eip);
2269   }
2270   // Set pc to handler
2271   exceptionInfo->ContextRecord->Eip = (DWORD)(DWORD_PTR)handler;
2272   #endif
2273 #endif
2274 
2275   // Continue the execution
2276   return EXCEPTION_CONTINUE_EXECUTION;
2277 }
2278 
2279 
2280 // Used for PostMortemDump
2281 extern "C" void safepoints();
2282 extern "C" void find(int x);
2283 extern "C" void events();
2284 
2285 // According to Windows API documentation, an illegal instruction sequence should generate
2286 // the 0xC000001C exception code. However, real world experience shows that occasionnaly
2287 // the execution of an illegal instruction can generate the exception code 0xC000001E. This
2288 // seems to be an undocumented feature of Win NT 4.0 (and probably other Windows systems).
2289 
2290 #define EXCEPTION_ILLEGAL_INSTRUCTION_2 0xC000001E
2291 
2292 // From "Execution Protection in the Windows Operating System" draft 0.35
2293 // Once a system header becomes available, the "real" define should be
2294 // included or copied here.
2295 #define EXCEPTION_INFO_EXEC_VIOLATION 0x08
2296 
2297 // Handle NAT Bit consumption on IA64.
2298 #ifdef _M_IA64
2299 #define EXCEPTION_REG_NAT_CONSUMPTION    STATUS_REG_NAT_CONSUMPTION
2300 #endif
2301 
2302 // Windows Vista/2008 heap corruption check
2303 #define EXCEPTION_HEAP_CORRUPTION        0xC0000374
2304 
2305 // All Visual C++ exceptions thrown from code generated by the Microsoft Visual
2306 // C++ compiler contain this error code. Because this is a compiler-generated
2307 // error, the code is not listed in the Win32 API header files.
2308 // The code is actually a cryptic mnemonic device, with the initial "E"
2309 // standing for "exception" and the final 3 bytes (0x6D7363) representing the
2310 // ASCII values of "msc".
2311 
2312 #define EXCEPTION_UNCAUGHT_CXX_EXCEPTION    0xE06D7363
2313 
2314 #define def_excpt(val) { #val, (val) }
2315 
2316 static const struct { char* name; uint number; } exceptlabels[] = {
2317     def_excpt(EXCEPTION_ACCESS_VIOLATION),
2318     def_excpt(EXCEPTION_DATATYPE_MISALIGNMENT),
2319     def_excpt(EXCEPTION_BREAKPOINT),
2320     def_excpt(EXCEPTION_SINGLE_STEP),
2321     def_excpt(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
2322     def_excpt(EXCEPTION_FLT_DENORMAL_OPERAND),
2323     def_excpt(EXCEPTION_FLT_DIVIDE_BY_ZERO),
2324     def_excpt(EXCEPTION_FLT_INEXACT_RESULT),
2325     def_excpt(EXCEPTION_FLT_INVALID_OPERATION),
2326     def_excpt(EXCEPTION_FLT_OVERFLOW),
2327     def_excpt(EXCEPTION_FLT_STACK_CHECK),
2328     def_excpt(EXCEPTION_FLT_UNDERFLOW),
2329     def_excpt(EXCEPTION_INT_DIVIDE_BY_ZERO),
2330     def_excpt(EXCEPTION_INT_OVERFLOW),
2331     def_excpt(EXCEPTION_PRIV_INSTRUCTION),
2332     def_excpt(EXCEPTION_IN_PAGE_ERROR),
2333     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION),
2334     def_excpt(EXCEPTION_ILLEGAL_INSTRUCTION_2),
2335     def_excpt(EXCEPTION_NONCONTINUABLE_EXCEPTION),
2336     def_excpt(EXCEPTION_STACK_OVERFLOW),
2337     def_excpt(EXCEPTION_INVALID_DISPOSITION),
2338     def_excpt(EXCEPTION_GUARD_PAGE),
2339     def_excpt(EXCEPTION_INVALID_HANDLE),
2340     def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
2341     def_excpt(EXCEPTION_HEAP_CORRUPTION)
2342 #ifdef _M_IA64
2343     , def_excpt(EXCEPTION_REG_NAT_CONSUMPTION)
2344 #endif
2345 };
2346 
2347 const char* os::exception_name(int exception_code, char *buf, size_t size) {
2348   uint code = static_cast<uint>(exception_code);
2349   for (uint i = 0; i < ARRAY_SIZE(exceptlabels); ++i) {
2350     if (exceptlabels[i].number == code) {
2351        jio_snprintf(buf, size, "%s", exceptlabels[i].name);
2352        return buf;
2353     }
2354   }
2355 
2356   return NULL;
2357 }
2358 
2359 //-----------------------------------------------------------------------------
2360 LONG Handle_IDiv_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2361   // handle exception caused by idiv; should only happen for -MinInt/-1
2362   // (division by zero is handled explicitly)
2363 #ifdef _M_IA64
2364   assert(0, "Fix Handle_IDiv_Exception");
2365 #else
2366   #ifdef  _M_AMD64
2367   PCONTEXT ctx = exceptionInfo->ContextRecord;
2368   address pc = (address)ctx->Rip;
2369   assert(pc[0] == 0xF7, "not an idiv opcode");
2370   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2371   assert(ctx->Rax == min_jint, "unexpected idiv exception");
2372   // set correct result values and continue after idiv instruction
2373   ctx->Rip = (DWORD64)pc + 2;        // idiv reg, reg  is 2 bytes
2374   ctx->Rax = (DWORD64)min_jint;      // result
2375   ctx->Rdx = (DWORD64)0;             // remainder
2376   // Continue the execution
2377   #else
2378   PCONTEXT ctx = exceptionInfo->ContextRecord;
2379   address pc = (address)ctx->Eip;
2380   assert(pc[0] == 0xF7, "not an idiv opcode");
2381   assert((pc[1] & ~0x7) == 0xF8, "cannot handle non-register operands");
2382   assert(ctx->Eax == min_jint, "unexpected idiv exception");
2383   // set correct result values and continue after idiv instruction
2384   ctx->Eip = (DWORD)pc + 2;        // idiv reg, reg  is 2 bytes
2385   ctx->Eax = (DWORD)min_jint;      // result
2386   ctx->Edx = (DWORD)0;             // remainder
2387   // Continue the execution
2388   #endif
2389 #endif
2390   return EXCEPTION_CONTINUE_EXECUTION;
2391 }
2392 
2393 #ifndef  _WIN64
2394 //-----------------------------------------------------------------------------
2395 LONG WINAPI Handle_FLT_Exception(struct _EXCEPTION_POINTERS* exceptionInfo) {
2396   // handle exception caused by native method modifying control word
2397   PCONTEXT ctx = exceptionInfo->ContextRecord;
2398   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2399 
2400   switch (exception_code) {
2401     case EXCEPTION_FLT_DENORMAL_OPERAND:
2402     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
2403     case EXCEPTION_FLT_INEXACT_RESULT:
2404     case EXCEPTION_FLT_INVALID_OPERATION:
2405     case EXCEPTION_FLT_OVERFLOW:
2406     case EXCEPTION_FLT_STACK_CHECK:
2407     case EXCEPTION_FLT_UNDERFLOW:
2408       jint fp_control_word = (* (jint*) StubRoutines::addr_fpu_cntrl_wrd_std());
2409       if (fp_control_word != ctx->FloatSave.ControlWord) {
2410         // Restore FPCW and mask out FLT exceptions
2411         ctx->FloatSave.ControlWord = fp_control_word | 0xffffffc0;
2412         // Mask out pending FLT exceptions
2413         ctx->FloatSave.StatusWord &=  0xffffff00;
2414         return EXCEPTION_CONTINUE_EXECUTION;
2415       }
2416   }
2417 
2418   if (prev_uef_handler != NULL) {
2419     // We didn't handle this exception so pass it to the previous
2420     // UnhandledExceptionFilter.
2421     return (prev_uef_handler)(exceptionInfo);
2422   }
2423 
2424   return EXCEPTION_CONTINUE_SEARCH;
2425 }
2426 #else //_WIN64
2427 /*
2428   On Windows, the mxcsr control bits are non-volatile across calls
2429   See also CR 6192333
2430   If EXCEPTION_FLT_* happened after some native method modified
2431   mxcsr - it is not a jvm fault.
2432   However should we decide to restore of mxcsr after a faulty
2433   native method we can uncomment following code
2434       jint MxCsr = INITIAL_MXCSR;
2435         // we can't use StubRoutines::addr_mxcsr_std()
2436         // because in Win64 mxcsr is not saved there
2437       if (MxCsr != ctx->MxCsr) {
2438         ctx->MxCsr = MxCsr;
2439         return EXCEPTION_CONTINUE_EXECUTION;
2440       }
2441 
2442 */
2443 #endif // _WIN64
2444 
2445 
2446 static inline void report_error(Thread* t, DWORD exception_code,
2447                                 address addr, void* siginfo, void* context) {
2448   VMError err(t, exception_code, addr, siginfo, context);
2449   err.report_and_die();
2450 
2451   // If UseOsErrorReporting, this will return here and save the error file
2452   // somewhere where we can find it in the minidump.
2453 }
2454 
2455 //-----------------------------------------------------------------------------
2456 LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2457   if (InterceptOSException) return EXCEPTION_CONTINUE_SEARCH;
2458   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2459 #ifdef _M_IA64
2460   // On Itanium, we need the "precise pc", which has the slot number coded
2461   // into the least 4 bits: 0000=slot0, 0100=slot1, 1000=slot2 (Windows format).
2462   address pc = (address) exceptionInfo->ExceptionRecord->ExceptionAddress;
2463   // Convert the pc to "Unix format", which has the slot number coded
2464   // into the least 2 bits: 0000=slot0, 0001=slot1, 0010=slot2
2465   // This is needed for IA64 because "relocation" / "implicit null check" / "poll instruction"
2466   // information is saved in the Unix format.
2467   address pc_unix_format = (address) ((((uint64_t)pc) & 0xFFFFFFFFFFFFFFF0) | ((((uint64_t)pc) & 0xF) >> 2));
2468 #else
2469   #ifdef _M_AMD64
2470   address pc = (address) exceptionInfo->ContextRecord->Rip;
2471   #else
2472   address pc = (address) exceptionInfo->ContextRecord->Eip;
2473   #endif
2474 #endif
2475   Thread* t = ThreadLocalStorage::get_thread_slow();          // slow & steady
2476 
2477   // Handle SafeFetch32 and SafeFetchN exceptions.
2478   if (StubRoutines::is_safefetch_fault(pc)) {
2479     return Handle_Exception(exceptionInfo, StubRoutines::continuation_for_safefetch_fault(pc));
2480   }
2481 
2482 #ifndef _WIN64
2483   // Execution protection violation - win32 running on AMD64 only
2484   // Handled first to avoid misdiagnosis as a "normal" access violation;
2485   // This is safe to do because we have a new/unique ExceptionInformation
2486   // code for this condition.
2487   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2488     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2489     int exception_subcode = (int) exceptionRecord->ExceptionInformation[0];
2490     address addr = (address) exceptionRecord->ExceptionInformation[1];
2491 
2492     if (exception_subcode == EXCEPTION_INFO_EXEC_VIOLATION) {
2493       int page_size = os::vm_page_size();
2494 
2495       // Make sure the pc and the faulting address are sane.
2496       //
2497       // If an instruction spans a page boundary, and the page containing
2498       // the beginning of the instruction is executable but the following
2499       // page is not, the pc and the faulting address might be slightly
2500       // different - we still want to unguard the 2nd page in this case.
2501       //
2502       // 15 bytes seems to be a (very) safe value for max instruction size.
2503       bool pc_is_near_addr =
2504         (pointer_delta((void*) addr, (void*) pc, sizeof(char)) < 15);
2505       bool instr_spans_page_boundary =
2506         (align_size_down((intptr_t) pc ^ (intptr_t) addr,
2507                          (intptr_t) page_size) > 0);
2508 
2509       if (pc == addr || (pc_is_near_addr && instr_spans_page_boundary)) {
2510         static volatile address last_addr =
2511           (address) os::non_memory_address_word();
2512 
2513         // In conservative mode, don't unguard unless the address is in the VM
2514         if (UnguardOnExecutionViolation > 0 && addr != last_addr &&
2515             (UnguardOnExecutionViolation > 1 || os::address_is_in_vm(addr))) {
2516 
2517           // Set memory to RWX and retry
2518           address page_start =
2519             (address) align_size_down((intptr_t) addr, (intptr_t) page_size);
2520           bool res = os::protect_memory((char*) page_start, page_size,
2521                                         os::MEM_PROT_RWX);
2522 
2523           if (PrintMiscellaneous && Verbose) {
2524             char buf[256];
2525             jio_snprintf(buf, sizeof(buf), "Execution protection violation "
2526                          "at " INTPTR_FORMAT
2527                          ", unguarding " INTPTR_FORMAT ": %s", addr,
2528                          page_start, (res ? "success" : strerror(errno)));
2529             tty->print_raw_cr(buf);
2530           }
2531 
2532           // Set last_addr so if we fault again at the same address, we don't
2533           // end up in an endless loop.
2534           //
2535           // There are two potential complications here.  Two threads trapping
2536           // at the same address at the same time could cause one of the
2537           // threads to think it already unguarded, and abort the VM.  Likely
2538           // very rare.
2539           //
2540           // The other race involves two threads alternately trapping at
2541           // different addresses and failing to unguard the page, resulting in
2542           // an endless loop.  This condition is probably even more unlikely
2543           // than the first.
2544           //
2545           // Although both cases could be avoided by using locks or thread
2546           // local last_addr, these solutions are unnecessary complication:
2547           // this handler is a best-effort safety net, not a complete solution.
2548           // It is disabled by default and should only be used as a workaround
2549           // in case we missed any no-execute-unsafe VM code.
2550 
2551           last_addr = addr;
2552 
2553           return EXCEPTION_CONTINUE_EXECUTION;
2554         }
2555       }
2556 
2557       // Last unguard failed or not unguarding
2558       tty->print_raw_cr("Execution protection violation");
2559       report_error(t, exception_code, addr, exceptionInfo->ExceptionRecord,
2560                    exceptionInfo->ContextRecord);
2561       return EXCEPTION_CONTINUE_SEARCH;
2562     }
2563   }
2564 #endif // _WIN64
2565 
2566   // Check to see if we caught the safepoint code in the
2567   // process of write protecting the memory serialization page.
2568   // It write enables the page immediately after protecting it
2569   // so just return.
2570   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
2571     JavaThread* thread = (JavaThread*) t;
2572     PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2573     address addr = (address) exceptionRecord->ExceptionInformation[1];
2574     if ( os::is_memory_serialize_page(thread, addr) ) {
2575       // Block current thread until the memory serialize page permission restored.
2576       os::block_on_serialize_page_trap();
2577       return EXCEPTION_CONTINUE_EXECUTION;
2578     }
2579   }
2580 
2581   if ((exception_code == EXCEPTION_ACCESS_VIOLATION) &&
2582       VM_Version::is_cpuinfo_segv_addr(pc)) {
2583     // Verify that OS save/restore AVX registers.
2584     return Handle_Exception(exceptionInfo, VM_Version::cpuinfo_cont_addr());
2585   }
2586 
2587   if (t != NULL && t->is_Java_thread()) {
2588     JavaThread* thread = (JavaThread*) t;
2589     bool in_java = thread->thread_state() == _thread_in_Java;
2590 
2591     // Handle potential stack overflows up front.
2592     if (exception_code == EXCEPTION_STACK_OVERFLOW) {
2593       if (os::uses_stack_guard_pages()) {
2594 #ifdef _M_IA64
2595         // Use guard page for register stack.
2596         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2597         address addr = (address) exceptionRecord->ExceptionInformation[1];
2598         // Check for a register stack overflow on Itanium
2599         if (thread->addr_inside_register_stack_red_zone(addr)) {
2600           // Fatal red zone violation happens if the Java program
2601           // catches a StackOverflow error and does so much processing
2602           // that it runs beyond the unprotected yellow guard zone. As
2603           // a result, we are out of here.
2604           fatal("ERROR: Unrecoverable stack overflow happened. JVM will exit.");
2605         } else if(thread->addr_inside_register_stack(addr)) {
2606           // Disable the yellow zone which sets the state that
2607           // we've got a stack overflow problem.
2608           if (thread->stack_yellow_zone_enabled()) {
2609             thread->disable_stack_yellow_zone();
2610           }
2611           // Give us some room to process the exception.
2612           thread->disable_register_stack_guard();
2613           // Tracing with +Verbose.
2614           if (Verbose) {
2615             tty->print_cr("SOF Compiled Register Stack overflow at " INTPTR_FORMAT " (SIGSEGV)", pc);
2616             tty->print_cr("Register Stack access at " INTPTR_FORMAT, addr);
2617             tty->print_cr("Register Stack base " INTPTR_FORMAT, thread->register_stack_base());
2618             tty->print_cr("Register Stack [" INTPTR_FORMAT "," INTPTR_FORMAT "]",
2619                           thread->register_stack_base(),
2620                           thread->register_stack_base() + thread->stack_size());
2621           }
2622 
2623           // Reguard the permanent register stack red zone just to be sure.
2624           // We saw Windows silently disabling this without telling us.
2625           thread->enable_register_stack_red_zone();
2626 
2627           return Handle_Exception(exceptionInfo,
2628             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2629         }
2630 #endif
2631         if (thread->stack_yellow_zone_enabled()) {
2632           // Yellow zone violation.  The o/s has unprotected the first yellow
2633           // zone page for us.  Note:  must call disable_stack_yellow_zone to
2634           // update the enabled status, even if the zone contains only one page.
2635           thread->disable_stack_yellow_zone();
2636           // If not in java code, return and hope for the best.
2637           return in_java ? Handle_Exception(exceptionInfo,
2638             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW))
2639             :  EXCEPTION_CONTINUE_EXECUTION;
2640         } else {
2641           // Fatal red zone violation.
2642           thread->disable_stack_red_zone();
2643           tty->print_raw_cr("An unrecoverable stack overflow has occurred.");
2644           report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2645                        exceptionInfo->ContextRecord);
2646           return EXCEPTION_CONTINUE_SEARCH;
2647         }
2648       } else if (in_java) {
2649         // JVM-managed guard pages cannot be used on win95/98.  The o/s provides
2650         // a one-time-only guard page, which it has released to us.  The next
2651         // stack overflow on this thread will result in an ACCESS_VIOLATION.
2652         return Handle_Exception(exceptionInfo,
2653           SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2654       } else {
2655         // Can only return and hope for the best.  Further stack growth will
2656         // result in an ACCESS_VIOLATION.
2657         return EXCEPTION_CONTINUE_EXECUTION;
2658       }
2659     } else if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2660       // Either stack overflow or null pointer exception.
2661       if (in_java) {
2662         PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2663         address addr = (address) exceptionRecord->ExceptionInformation[1];
2664         address stack_end = thread->stack_base() - thread->stack_size();
2665         if (addr < stack_end && addr >= stack_end - os::vm_page_size()) {
2666           // Stack overflow.
2667           assert(!os::uses_stack_guard_pages(),
2668             "should be caught by red zone code above.");
2669           return Handle_Exception(exceptionInfo,
2670             SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW));
2671         }
2672         //
2673         // Check for safepoint polling and implicit null
2674         // We only expect null pointers in the stubs (vtable)
2675         // the rest are checked explicitly now.
2676         //
2677         CodeBlob* cb = CodeCache::find_blob(pc);
2678         if (cb != NULL) {
2679           if (os::is_poll_address(addr)) {
2680             address stub = SharedRuntime::get_poll_stub(pc);
2681             return Handle_Exception(exceptionInfo, stub);
2682           }
2683         }
2684         {
2685 #ifdef _WIN64
2686           //
2687           // If it's a legal stack address map the entire region in
2688           //
2689           PEXCEPTION_RECORD exceptionRecord = exceptionInfo->ExceptionRecord;
2690           address addr = (address) exceptionRecord->ExceptionInformation[1];
2691           if (addr > thread->stack_yellow_zone_base() && addr < thread->stack_base() ) {
2692                   addr = (address)((uintptr_t)addr &
2693                          (~((uintptr_t)os::vm_page_size() - (uintptr_t)1)));
2694                   os::commit_memory((char *)addr, thread->stack_base() - addr,
2695                                     !ExecMem);
2696                   return EXCEPTION_CONTINUE_EXECUTION;
2697           }
2698           else
2699 #endif
2700           {
2701             // Null pointer exception.
2702 #ifdef _M_IA64
2703             // Process implicit null checks in compiled code. Note: Implicit null checks
2704             // can happen even if "ImplicitNullChecks" is disabled, e.g. in vtable stubs.
2705             if (CodeCache::contains((void*) pc_unix_format) && !MacroAssembler::needs_explicit_null_check((intptr_t) addr)) {
2706               CodeBlob *cb = CodeCache::find_blob_unsafe(pc_unix_format);
2707               // Handle implicit null check in UEP method entry
2708               if (cb && (cb->is_frame_complete_at(pc) ||
2709                          (cb->is_nmethod() && ((nmethod *)cb)->inlinecache_check_contains(pc)))) {
2710                 if (Verbose) {
2711                   intptr_t *bundle_start = (intptr_t*) ((intptr_t) pc_unix_format & 0xFFFFFFFFFFFFFFF0);
2712                   tty->print_cr("trap: null_check at " INTPTR_FORMAT " (SIGSEGV)", pc_unix_format);
2713                   tty->print_cr("      to addr " INTPTR_FORMAT, addr);
2714                   tty->print_cr("      bundle is " INTPTR_FORMAT " (high), " INTPTR_FORMAT " (low)",
2715                                 *(bundle_start + 1), *bundle_start);
2716                 }
2717                 return Handle_Exception(exceptionInfo,
2718                   SharedRuntime::continuation_for_implicit_exception(thread, pc_unix_format, SharedRuntime::IMPLICIT_NULL));
2719               }
2720             }
2721 
2722             // Implicit null checks were processed above.  Hence, we should not reach
2723             // here in the usual case => die!
2724             if (Verbose) tty->print_raw_cr("Access violation, possible null pointer exception");
2725             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2726                          exceptionInfo->ContextRecord);
2727             return EXCEPTION_CONTINUE_SEARCH;
2728 
2729 #else // !IA64
2730 
2731             // Windows 98 reports faulting addresses incorrectly
2732             if (!MacroAssembler::needs_explicit_null_check((intptr_t)addr) ||
2733                 !os::win32::is_nt()) {
2734               address stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL);
2735               if (stub != NULL) return Handle_Exception(exceptionInfo, stub);
2736             }
2737             report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2738                          exceptionInfo->ContextRecord);
2739             return EXCEPTION_CONTINUE_SEARCH;
2740 #endif
2741           }
2742         }
2743       }
2744 
2745 #ifdef _WIN64
2746       // Special care for fast JNI field accessors.
2747       // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks
2748       // in and the heap gets shrunk before the field access.
2749       if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2750         address addr = JNI_FastGetField::find_slowcase_pc(pc);
2751         if (addr != (address)-1) {
2752           return Handle_Exception(exceptionInfo, addr);
2753         }
2754       }
2755 #endif
2756 
2757       // Stack overflow or null pointer exception in native code.
2758       report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2759                    exceptionInfo->ContextRecord);
2760       return EXCEPTION_CONTINUE_SEARCH;
2761     } // /EXCEPTION_ACCESS_VIOLATION
2762     // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
2763 #if defined _M_IA64
2764     else if ((exception_code == EXCEPTION_ILLEGAL_INSTRUCTION ||
2765               exception_code == EXCEPTION_ILLEGAL_INSTRUCTION_2)) {
2766       M37 handle_wrong_method_break(0, NativeJump::HANDLE_WRONG_METHOD, PR0);
2767 
2768       // Compiled method patched to be non entrant? Following conditions must apply:
2769       // 1. must be first instruction in bundle
2770       // 2. must be a break instruction with appropriate code
2771       if((((uint64_t) pc & 0x0F) == 0) &&
2772          (((IPF_Bundle*) pc)->get_slot0() == handle_wrong_method_break.bits())) {
2773         return Handle_Exception(exceptionInfo,
2774                                 (address)SharedRuntime::get_handle_wrong_method_stub());
2775       }
2776     } // /EXCEPTION_ILLEGAL_INSTRUCTION
2777 #endif
2778 
2779 
2780     if (in_java) {
2781       switch (exception_code) {
2782       case EXCEPTION_INT_DIVIDE_BY_ZERO:
2783         return Handle_Exception(exceptionInfo, SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_DIVIDE_BY_ZERO));
2784 
2785       case EXCEPTION_INT_OVERFLOW:
2786         return Handle_IDiv_Exception(exceptionInfo);
2787 
2788       } // switch
2789     }
2790 #ifndef _WIN64
2791     if (((thread->thread_state() == _thread_in_Java) ||
2792         (thread->thread_state() == _thread_in_native)) &&
2793         exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
2794     {
2795       LONG result=Handle_FLT_Exception(exceptionInfo);
2796       if (result==EXCEPTION_CONTINUE_EXECUTION) return result;
2797     }
2798 #endif //_WIN64
2799   }
2800 
2801   if (exception_code != EXCEPTION_BREAKPOINT) {
2802     report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
2803                  exceptionInfo->ContextRecord);
2804   }
2805   return EXCEPTION_CONTINUE_SEARCH;
2806 }
2807 
2808 #ifndef _WIN64
2809 // Special care for fast JNI accessors.
2810 // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in and
2811 // the heap gets shrunk before the field access.
2812 // Need to install our own structured exception handler since native code may
2813 // install its own.
2814 LONG WINAPI fastJNIAccessorExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo) {
2815   DWORD exception_code = exceptionInfo->ExceptionRecord->ExceptionCode;
2816   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
2817     address pc = (address) exceptionInfo->ContextRecord->Eip;
2818     address addr = JNI_FastGetField::find_slowcase_pc(pc);
2819     if (addr != (address)-1) {
2820       return Handle_Exception(exceptionInfo, addr);
2821     }
2822   }
2823   return EXCEPTION_CONTINUE_SEARCH;
2824 }
2825 
2826 #define DEFINE_FAST_GETFIELD(Return,Fieldname,Result) \
2827 Return JNICALL jni_fast_Get##Result##Field_wrapper(JNIEnv *env, jobject obj, jfieldID fieldID) { \
2828   __try { \
2829     return (*JNI_FastGetField::jni_fast_Get##Result##Field_fp)(env, obj, fieldID); \
2830   } __except(fastJNIAccessorExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) { \
2831   } \
2832   return 0; \
2833 }
2834 
2835 DEFINE_FAST_GETFIELD(jboolean, bool,   Boolean)
2836 DEFINE_FAST_GETFIELD(jbyte,    byte,   Byte)
2837 DEFINE_FAST_GETFIELD(jchar,    char,   Char)
2838 DEFINE_FAST_GETFIELD(jshort,   short,  Short)
2839 DEFINE_FAST_GETFIELD(jint,     int,    Int)
2840 DEFINE_FAST_GETFIELD(jlong,    long,   Long)
2841 DEFINE_FAST_GETFIELD(jfloat,   float,  Float)
2842 DEFINE_FAST_GETFIELD(jdouble,  double, Double)
2843 
2844 address os::win32::fast_jni_accessor_wrapper(BasicType type) {
2845   switch (type) {
2846     case T_BOOLEAN: return (address)jni_fast_GetBooleanField_wrapper;
2847     case T_BYTE:    return (address)jni_fast_GetByteField_wrapper;
2848     case T_CHAR:    return (address)jni_fast_GetCharField_wrapper;
2849     case T_SHORT:   return (address)jni_fast_GetShortField_wrapper;
2850     case T_INT:     return (address)jni_fast_GetIntField_wrapper;
2851     case T_LONG:    return (address)jni_fast_GetLongField_wrapper;
2852     case T_FLOAT:   return (address)jni_fast_GetFloatField_wrapper;
2853     case T_DOUBLE:  return (address)jni_fast_GetDoubleField_wrapper;
2854     default:        ShouldNotReachHere();
2855   }
2856   return (address)-1;
2857 }
2858 #endif
2859 
2860 void os::win32::call_test_func_with_wrapper(void (*funcPtr)(void)) {
2861   // Install a win32 structured exception handler around the test
2862   // function call so the VM can generate an error dump if needed.
2863   __try {
2864     (*funcPtr)();
2865   } __except(topLevelExceptionFilter(
2866              (_EXCEPTION_POINTERS*)_exception_info())) {
2867     // Nothing to do.
2868   }
2869 }
2870 
2871 // Virtual Memory
2872 
2873 int os::vm_page_size() { return os::win32::vm_page_size(); }
2874 int os::vm_allocation_granularity() {
2875   return os::win32::vm_allocation_granularity();
2876 }
2877 
2878 // Windows large page support is available on Windows 2003. In order to use
2879 // large page memory, the administrator must first assign additional privilege
2880 // to the user:
2881 //   + select Control Panel -> Administrative Tools -> Local Security Policy
2882 //   + select Local Policies -> User Rights Assignment
2883 //   + double click "Lock pages in memory", add users and/or groups
2884 //   + reboot
2885 // Note the above steps are needed for administrator as well, as administrators
2886 // by default do not have the privilege to lock pages in memory.
2887 //
2888 // Note about Windows 2003: although the API supports committing large page
2889 // memory on a page-by-page basis and VirtualAlloc() returns success under this
2890 // scenario, I found through experiment it only uses large page if the entire
2891 // memory region is reserved and committed in a single VirtualAlloc() call.
2892 // This makes Windows large page support more or less like Solaris ISM, in
2893 // that the entire heap must be committed upfront. This probably will change
2894 // in the future, if so the code below needs to be revisited.
2895 
2896 #ifndef MEM_LARGE_PAGES
2897 #define MEM_LARGE_PAGES 0x20000000
2898 #endif
2899 
2900 static HANDLE    _hProcess;
2901 static HANDLE    _hToken;
2902 
2903 // Container for NUMA node list info
2904 class NUMANodeListHolder {
2905 private:
2906   int *_numa_used_node_list;  // allocated below
2907   int _numa_used_node_count;
2908 
2909   void free_node_list() {
2910     if (_numa_used_node_list != NULL) {
2911       FREE_C_HEAP_ARRAY(int, _numa_used_node_list, mtInternal);
2912     }
2913   }
2914 
2915 public:
2916   NUMANodeListHolder() {
2917     _numa_used_node_count = 0;
2918     _numa_used_node_list = NULL;
2919     // do rest of initialization in build routine (after function pointers are set up)
2920   }
2921 
2922   ~NUMANodeListHolder() {
2923     free_node_list();
2924   }
2925 
2926   bool build() {
2927     DWORD_PTR proc_aff_mask;
2928     DWORD_PTR sys_aff_mask;
2929     if (!GetProcessAffinityMask(GetCurrentProcess(), &proc_aff_mask, &sys_aff_mask)) return false;
2930     ULONG highest_node_number;
2931     if (!os::Kernel32Dll::GetNumaHighestNodeNumber(&highest_node_number)) return false;
2932     free_node_list();
2933     _numa_used_node_list = NEW_C_HEAP_ARRAY(int, highest_node_number + 1, mtInternal);
2934     for (unsigned int i = 0; i <= highest_node_number; i++) {
2935       ULONGLONG proc_mask_numa_node;
2936       if (!os::Kernel32Dll::GetNumaNodeProcessorMask(i, &proc_mask_numa_node)) return false;
2937       if ((proc_aff_mask & proc_mask_numa_node)!=0) {
2938         _numa_used_node_list[_numa_used_node_count++] = i;
2939       }
2940     }
2941     return (_numa_used_node_count > 1);
2942   }
2943 
2944   int get_count() {return _numa_used_node_count;}
2945   int get_node_list_entry(int n) {
2946     // for indexes out of range, returns -1
2947     return (n < _numa_used_node_count ? _numa_used_node_list[n] : -1);
2948   }
2949 
2950 } numa_node_list_holder;
2951 
2952 
2953 
2954 static size_t _large_page_size = 0;
2955 
2956 static bool resolve_functions_for_large_page_init() {
2957   return os::Kernel32Dll::GetLargePageMinimumAvailable() &&
2958     os::Advapi32Dll::AdvapiAvailable();
2959 }
2960 
2961 static bool request_lock_memory_privilege() {
2962   _hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2963                                 os::current_process_id());
2964 
2965   LUID luid;
2966   if (_hProcess != NULL &&
2967       os::Advapi32Dll::OpenProcessToken(_hProcess, TOKEN_ADJUST_PRIVILEGES, &_hToken) &&
2968       os::Advapi32Dll::LookupPrivilegeValue(NULL, "SeLockMemoryPrivilege", &luid)) {
2969 
2970     TOKEN_PRIVILEGES tp;
2971     tp.PrivilegeCount = 1;
2972     tp.Privileges[0].Luid = luid;
2973     tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
2974 
2975     // AdjustTokenPrivileges() may return TRUE even when it couldn't change the
2976     // privilege. Check GetLastError() too. See MSDN document.
2977     if (os::Advapi32Dll::AdjustTokenPrivileges(_hToken, false, &tp, sizeof(tp), NULL, NULL) &&
2978         (GetLastError() == ERROR_SUCCESS)) {
2979       return true;
2980     }
2981   }
2982 
2983   return false;
2984 }
2985 
2986 static void cleanup_after_large_page_init() {
2987   if (_hProcess) CloseHandle(_hProcess);
2988   _hProcess = NULL;
2989   if (_hToken) CloseHandle(_hToken);
2990   _hToken = NULL;
2991 }
2992 
2993 static bool numa_interleaving_init() {
2994   bool success = false;
2995   bool use_numa_interleaving_specified = !FLAG_IS_DEFAULT(UseNUMAInterleaving);
2996 
2997   // print a warning if UseNUMAInterleaving flag is specified on command line
2998   bool warn_on_failure = use_numa_interleaving_specified;
2999 # define WARN(msg) if (warn_on_failure) { warning(msg); }
3000 
3001   // NUMAInterleaveGranularity cannot be less than vm_allocation_granularity (or _large_page_size if using large pages)
3002   size_t min_interleave_granularity = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
3003   NUMAInterleaveGranularity = align_size_up(NUMAInterleaveGranularity, min_interleave_granularity);
3004 
3005   if (os::Kernel32Dll::NumaCallsAvailable()) {
3006     if (numa_node_list_holder.build()) {
3007       if (PrintMiscellaneous && Verbose) {
3008         tty->print("NUMA UsedNodeCount=%d, namely ", numa_node_list_holder.get_count());
3009         for (int i = 0; i < numa_node_list_holder.get_count(); i++) {
3010           tty->print("%d ", numa_node_list_holder.get_node_list_entry(i));
3011         }
3012         tty->print("\n");
3013       }
3014       success = true;
3015     } else {
3016       WARN("Process does not cover multiple NUMA nodes.");
3017     }
3018   } else {
3019     WARN("NUMA Interleaving is not supported by the operating system.");
3020   }
3021   if (!success) {
3022     if (use_numa_interleaving_specified) WARN("...Ignoring UseNUMAInterleaving flag.");
3023   }
3024   return success;
3025 #undef WARN
3026 }
3027 
3028 // this routine is used whenever we need to reserve a contiguous VA range
3029 // but we need to make separate VirtualAlloc calls for each piece of the range
3030 // Reasons for doing this:
3031 //  * UseLargePagesIndividualAllocation was set (normally only needed on WS2003 but possible to be set otherwise)
3032 //  * UseNUMAInterleaving requires a separate node for each piece
3033 static char* allocate_pages_individually(size_t bytes, char* addr, DWORD flags, DWORD prot,
3034                                          bool should_inject_error=false) {
3035   char * p_buf;
3036   // note: at setup time we guaranteed that NUMAInterleaveGranularity was aligned up to a page size
3037   size_t page_size = UseLargePages ? _large_page_size : os::vm_allocation_granularity();
3038   size_t chunk_size = UseNUMAInterleaving ? NUMAInterleaveGranularity : page_size;
3039 
3040   // first reserve enough address space in advance since we want to be
3041   // able to break a single contiguous virtual address range into multiple
3042   // large page commits but WS2003 does not allow reserving large page space
3043   // so we just use 4K pages for reserve, this gives us a legal contiguous
3044   // address space. then we will deallocate that reservation, and re alloc
3045   // using large pages
3046   const size_t size_of_reserve = bytes + chunk_size;
3047   if (bytes > size_of_reserve) {
3048     // Overflowed.
3049     return NULL;
3050   }
3051   p_buf = (char *) VirtualAlloc(addr,
3052                                 size_of_reserve,  // size of Reserve
3053                                 MEM_RESERVE,
3054                                 PAGE_READWRITE);
3055   // If reservation failed, return NULL
3056   if (p_buf == NULL) return NULL;
3057   MemTracker::record_virtual_memory_reserve((address)p_buf, size_of_reserve, CALLER_PC);
3058   os::release_memory(p_buf, bytes + chunk_size);
3059 
3060   // we still need to round up to a page boundary (in case we are using large pages)
3061   // but not to a chunk boundary (in case InterleavingGranularity doesn't align with page size)
3062   // instead we handle this in the bytes_to_rq computation below
3063   p_buf = (char *) align_size_up((size_t)p_buf, page_size);
3064 
3065   // now go through and allocate one chunk at a time until all bytes are
3066   // allocated
3067   size_t  bytes_remaining = bytes;
3068   // An overflow of align_size_up() would have been caught above
3069   // in the calculation of size_of_reserve.
3070   char * next_alloc_addr = p_buf;
3071   HANDLE hProc = GetCurrentProcess();
3072 
3073 #ifdef ASSERT
3074   // Variable for the failure injection
3075   long ran_num = os::random();
3076   size_t fail_after = ran_num % bytes;
3077 #endif
3078 
3079   int count=0;
3080   while (bytes_remaining) {
3081     // select bytes_to_rq to get to the next chunk_size boundary
3082 
3083     size_t bytes_to_rq = MIN2(bytes_remaining, chunk_size - ((size_t)next_alloc_addr % chunk_size));
3084     // Note allocate and commit
3085     char * p_new;
3086 
3087 #ifdef ASSERT
3088     bool inject_error_now = should_inject_error && (bytes_remaining <= fail_after);
3089 #else
3090     const bool inject_error_now = false;
3091 #endif
3092 
3093     if (inject_error_now) {
3094       p_new = NULL;
3095     } else {
3096       if (!UseNUMAInterleaving) {
3097         p_new = (char *) VirtualAlloc(next_alloc_addr,
3098                                       bytes_to_rq,
3099                                       flags,
3100                                       prot);
3101       } else {
3102         // get the next node to use from the used_node_list
3103         assert(numa_node_list_holder.get_count() > 0, "Multiple NUMA nodes expected");
3104         DWORD node = numa_node_list_holder.get_node_list_entry(count % numa_node_list_holder.get_count());
3105         p_new = (char *)os::Kernel32Dll::VirtualAllocExNuma(hProc,
3106                                                             next_alloc_addr,
3107                                                             bytes_to_rq,
3108                                                             flags,
3109                                                             prot,
3110                                                             node);
3111       }
3112     }
3113 
3114     if (p_new == NULL) {
3115       // Free any allocated pages
3116       if (next_alloc_addr > p_buf) {
3117         // Some memory was committed so release it.
3118         size_t bytes_to_release = bytes - bytes_remaining;
3119         // NMT has yet to record any individual blocks, so it
3120         // need to create a dummy 'reserve' record to match
3121         // the release.
3122         MemTracker::record_virtual_memory_reserve((address)p_buf,
3123           bytes_to_release, CALLER_PC);
3124         os::release_memory(p_buf, bytes_to_release);
3125       }
3126 #ifdef ASSERT
3127       if (should_inject_error) {
3128         if (TracePageSizes && Verbose) {
3129           tty->print_cr("Reserving pages individually failed.");
3130         }
3131       }
3132 #endif
3133       return NULL;
3134     }
3135 
3136     bytes_remaining -= bytes_to_rq;
3137     next_alloc_addr += bytes_to_rq;
3138     count++;
3139   }
3140   // Although the memory is allocated individually, it is returned as one.
3141   // NMT records it as one block.
3142   if ((flags & MEM_COMMIT) != 0) {
3143     MemTracker::record_virtual_memory_reserve_and_commit((address)p_buf, bytes, CALLER_PC);
3144   } else {
3145     MemTracker::record_virtual_memory_reserve((address)p_buf, bytes, CALLER_PC);
3146   }
3147 
3148   // made it this far, success
3149   return p_buf;
3150 }
3151 
3152 
3153 
3154 void os::large_page_init() {
3155   if (!UseLargePages) return;
3156 
3157   // print a warning if any large page related flag is specified on command line
3158   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages) ||
3159                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3160   bool success = false;
3161 
3162 # define WARN(msg) if (warn_on_failure) { warning(msg); }
3163   if (resolve_functions_for_large_page_init()) {
3164     if (request_lock_memory_privilege()) {
3165       size_t s = os::Kernel32Dll::GetLargePageMinimum();
3166       if (s) {
3167 #if defined(IA32) || defined(AMD64)
3168         if (s > 4*M || LargePageSizeInBytes > 4*M) {
3169           WARN("JVM cannot use large pages bigger than 4mb.");
3170         } else {
3171 #endif
3172           if (LargePageSizeInBytes && LargePageSizeInBytes % s == 0) {
3173             _large_page_size = LargePageSizeInBytes;
3174           } else {
3175             _large_page_size = s;
3176           }
3177           success = true;
3178 #if defined(IA32) || defined(AMD64)
3179         }
3180 #endif
3181       } else {
3182         WARN("Large page is not supported by the processor.");
3183       }
3184     } else {
3185       WARN("JVM cannot use large page memory because it does not have enough privilege to lock pages in memory.");
3186     }
3187   } else {
3188     WARN("Large page is not supported by the operating system.");
3189   }
3190 #undef WARN
3191 
3192   const size_t default_page_size = (size_t) vm_page_size();
3193   if (success && _large_page_size > default_page_size) {
3194     _page_sizes[0] = _large_page_size;
3195     _page_sizes[1] = default_page_size;
3196     _page_sizes[2] = 0;
3197   }
3198 
3199   cleanup_after_large_page_init();
3200   UseLargePages = success;
3201 }
3202 
3203 // On win32, one cannot release just a part of reserved memory, it's an
3204 // all or nothing deal.  When we split a reservation, we must break the
3205 // reservation into two reservations.
3206 void os::pd_split_reserved_memory(char *base, size_t size, size_t split,
3207                               bool realloc) {
3208   if (size > 0) {
3209     release_memory(base, size);
3210     if (realloc) {
3211       reserve_memory(split, base);
3212     }
3213     if (size != split) {
3214       reserve_memory(size - split, base + split);
3215     }
3216   }
3217 }
3218 
3219 // Multiple threads can race in this code but it's not possible to unmap small sections of
3220 // virtual space to get requested alignment, like posix-like os's.
3221 // Windows prevents multiple thread from remapping over each other so this loop is thread-safe.
3222 char* os::reserve_memory_aligned(size_t size, size_t alignment) {
3223   assert((alignment & (os::vm_allocation_granularity() - 1)) == 0,
3224       "Alignment must be a multiple of allocation granularity (page size)");
3225   assert((size & (alignment -1)) == 0, "size must be 'alignment' aligned");
3226 
3227   size_t extra_size = size + alignment;
3228   assert(extra_size >= size, "overflow, size is too large to allow alignment");
3229 
3230   char* aligned_base = NULL;
3231 
3232   do {
3233     char* extra_base = os::reserve_memory(extra_size, NULL, alignment);
3234     if (extra_base == NULL) {
3235       return NULL;
3236     }
3237     // Do manual alignment
3238     aligned_base = (char*) align_size_up((uintptr_t) extra_base, alignment);
3239 
3240     os::release_memory(extra_base, extra_size);
3241 
3242     aligned_base = os::reserve_memory(size, aligned_base);
3243 
3244   } while (aligned_base == NULL);
3245 
3246   return aligned_base;
3247 }
3248 
3249 char* os::pd_reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
3250   assert((size_t)addr % os::vm_allocation_granularity() == 0,
3251          "reserve alignment");
3252   assert(bytes % os::vm_allocation_granularity() == 0, "reserve block size");
3253   char* res;
3254   // note that if UseLargePages is on, all the areas that require interleaving
3255   // will go thru reserve_memory_special rather than thru here.
3256   bool use_individual = (UseNUMAInterleaving && !UseLargePages);
3257   if (!use_individual) {
3258     res = (char*)VirtualAlloc(addr, bytes, MEM_RESERVE, PAGE_READWRITE);
3259   } else {
3260     elapsedTimer reserveTimer;
3261     if( Verbose && PrintMiscellaneous ) reserveTimer.start();
3262     // in numa interleaving, we have to allocate pages individually
3263     // (well really chunks of NUMAInterleaveGranularity size)
3264     res = allocate_pages_individually(bytes, addr, MEM_RESERVE, PAGE_READWRITE);
3265     if (res == NULL) {
3266       warning("NUMA page allocation failed");
3267     }
3268     if( Verbose && PrintMiscellaneous ) {
3269       reserveTimer.stop();
3270       tty->print_cr("reserve_memory of %Ix bytes took " JLONG_FORMAT " ms (" JLONG_FORMAT " ticks)", bytes,
3271                     reserveTimer.milliseconds(), reserveTimer.ticks());
3272     }
3273   }
3274   assert(res == NULL || addr == NULL || addr == res,
3275          "Unexpected address from reserve.");
3276 
3277   return res;
3278 }
3279 
3280 // Reserve memory at an arbitrary address, only if that area is
3281 // available (and not reserved for something else).
3282 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3283   // Windows os::reserve_memory() fails of the requested address range is
3284   // not avilable.
3285   return reserve_memory(bytes, requested_addr);
3286 }
3287 
3288 size_t os::large_page_size() {
3289   return _large_page_size;
3290 }
3291 
3292 bool os::can_commit_large_page_memory() {
3293   // Windows only uses large page memory when the entire region is reserved
3294   // and committed in a single VirtualAlloc() call. This may change in the
3295   // future, but with Windows 2003 it's not possible to commit on demand.
3296   return false;
3297 }
3298 
3299 bool os::can_execute_large_page_memory() {
3300   return true;
3301 }
3302 
3303 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* addr, bool exec) {
3304   assert(UseLargePages, "only for large pages");
3305 
3306   if (!is_size_aligned(bytes, os::large_page_size()) || alignment > os::large_page_size()) {
3307     return NULL; // Fallback to small pages.
3308   }
3309 
3310   const DWORD prot = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
3311   const DWORD flags = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3312 
3313   // with large pages, there are two cases where we need to use Individual Allocation
3314   // 1) the UseLargePagesIndividualAllocation flag is set (set by default on WS2003)
3315   // 2) NUMA Interleaving is enabled, in which case we use a different node for each page
3316   if (UseLargePagesIndividualAllocation || UseNUMAInterleaving) {
3317     if (TracePageSizes && Verbose) {
3318        tty->print_cr("Reserving large pages individually.");
3319     }
3320     char * p_buf = allocate_pages_individually(bytes, addr, flags, prot, LargePagesIndividualAllocationInjectError);
3321     if (p_buf == NULL) {
3322       // give an appropriate warning message
3323       if (UseNUMAInterleaving) {
3324         warning("NUMA large page allocation failed, UseLargePages flag ignored");
3325       }
3326       if (UseLargePagesIndividualAllocation) {
3327         warning("Individually allocated large pages failed, "
3328                 "use -XX:-UseLargePagesIndividualAllocation to turn off");
3329       }
3330       return NULL;
3331     }
3332 
3333     return p_buf;
3334 
3335   } else {
3336     if (TracePageSizes && Verbose) {
3337        tty->print_cr("Reserving large pages in a single large chunk.");
3338     }
3339     // normal policy just allocate it all at once
3340     DWORD flag = MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES;
3341     char * res = (char *)VirtualAlloc(addr, bytes, flag, prot);
3342     if (res != NULL) {
3343       MemTracker::record_virtual_memory_reserve_and_commit((address)res, bytes, CALLER_PC);
3344     }
3345 
3346     return res;
3347   }
3348 }
3349 
3350 bool os::release_memory_special(char* base, size_t bytes) {
3351   assert(base != NULL, "Sanity check");
3352   return release_memory(base, bytes);
3353 }
3354 
3355 void os::print_statistics() {
3356 }
3357 
3358 static void warn_fail_commit_memory(char* addr, size_t bytes, bool exec) {
3359   int err = os::get_last_error();
3360   char buf[256];
3361   size_t buf_len = os::lasterror(buf, sizeof(buf));
3362   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
3363           ", %d) failed; error='%s' (DOS error/errno=%d)", addr, bytes,
3364           exec, buf_len != 0 ? buf : "<no_error_string>", err);
3365 }
3366 
3367 bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
3368   if (bytes == 0) {
3369     // Don't bother the OS with noops.
3370     return true;
3371   }
3372   assert((size_t) addr % os::vm_page_size() == 0, "commit on page boundaries");
3373   assert(bytes % os::vm_page_size() == 0, "commit in page-sized chunks");
3374   // Don't attempt to print anything if the OS call fails. We're
3375   // probably low on resources, so the print itself may cause crashes.
3376 
3377   // unless we have NUMAInterleaving enabled, the range of a commit
3378   // is always within a reserve covered by a single VirtualAlloc
3379   // in that case we can just do a single commit for the requested size
3380   if (!UseNUMAInterleaving) {
3381     if (VirtualAlloc(addr, bytes, MEM_COMMIT, PAGE_READWRITE) == NULL) {
3382       NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3383       return false;
3384     }
3385     if (exec) {
3386       DWORD oldprot;
3387       // Windows doc says to use VirtualProtect to get execute permissions
3388       if (!VirtualProtect(addr, bytes, PAGE_EXECUTE_READWRITE, &oldprot)) {
3389         NOT_PRODUCT(warn_fail_commit_memory(addr, bytes, exec);)
3390         return false;
3391       }
3392     }
3393     return true;
3394   } else {
3395 
3396     // when NUMAInterleaving is enabled, the commit might cover a range that
3397     // came from multiple VirtualAlloc reserves (using allocate_pages_individually).
3398     // VirtualQuery can help us determine that.  The RegionSize that VirtualQuery
3399     // returns represents the number of bytes that can be committed in one step.
3400     size_t bytes_remaining = bytes;
3401     char * next_alloc_addr = addr;
3402     while (bytes_remaining > 0) {
3403       MEMORY_BASIC_INFORMATION alloc_info;
3404       VirtualQuery(next_alloc_addr, &alloc_info, sizeof(alloc_info));
3405       size_t bytes_to_rq = MIN2(bytes_remaining, (size_t)alloc_info.RegionSize);
3406       if (VirtualAlloc(next_alloc_addr, bytes_to_rq, MEM_COMMIT,
3407                        PAGE_READWRITE) == NULL) {
3408         NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3409                                             exec);)
3410         return false;
3411       }
3412       if (exec) {
3413         DWORD oldprot;
3414         if (!VirtualProtect(next_alloc_addr, bytes_to_rq,
3415                             PAGE_EXECUTE_READWRITE, &oldprot)) {
3416           NOT_PRODUCT(warn_fail_commit_memory(next_alloc_addr, bytes_to_rq,
3417                                               exec);)
3418           return false;
3419         }
3420       }
3421       bytes_remaining -= bytes_to_rq;
3422       next_alloc_addr += bytes_to_rq;
3423     }
3424   }
3425   // if we made it this far, return true
3426   return true;
3427 }
3428 
3429 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
3430                        bool exec) {
3431   // alignment_hint is ignored on this OS
3432   return pd_commit_memory(addr, size, exec);
3433 }
3434 
3435 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
3436                                   const char* mesg) {
3437   assert(mesg != NULL, "mesg must be specified");
3438   if (!pd_commit_memory(addr, size, exec)) {
3439     warn_fail_commit_memory(addr, size, exec);
3440     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
3441   }
3442 }
3443 
3444 void os::pd_commit_memory_or_exit(char* addr, size_t size,
3445                                   size_t alignment_hint, bool exec,
3446                                   const char* mesg) {
3447   // alignment_hint is ignored on this OS
3448   pd_commit_memory_or_exit(addr, size, exec, mesg);
3449 }
3450 
3451 bool os::pd_uncommit_memory(char* addr, size_t bytes) {
3452   if (bytes == 0) {
3453     // Don't bother the OS with noops.
3454     return true;
3455   }
3456   assert((size_t) addr % os::vm_page_size() == 0, "uncommit on page boundaries");
3457   assert(bytes % os::vm_page_size() == 0, "uncommit in page-sized chunks");
3458   return (VirtualFree(addr, bytes, MEM_DECOMMIT) != 0);
3459 }
3460 
3461 bool os::pd_release_memory(char* addr, size_t bytes) {
3462   return VirtualFree(addr, 0, MEM_RELEASE) != 0;
3463 }
3464 
3465 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3466   return os::commit_memory(addr, size, !ExecMem);
3467 }
3468 
3469 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3470   return os::uncommit_memory(addr, size);
3471 }
3472 
3473 // Set protections specified
3474 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3475                         bool is_committed) {
3476   unsigned int p = 0;
3477   switch (prot) {
3478   case MEM_PROT_NONE: p = PAGE_NOACCESS; break;
3479   case MEM_PROT_READ: p = PAGE_READONLY; break;
3480   case MEM_PROT_RW:   p = PAGE_READWRITE; break;
3481   case MEM_PROT_RWX:  p = PAGE_EXECUTE_READWRITE; break;
3482   default:
3483     ShouldNotReachHere();
3484   }
3485 
3486   DWORD old_status;
3487 
3488   // Strange enough, but on Win32 one can change protection only for committed
3489   // memory, not a big deal anyway, as bytes less or equal than 64K
3490   if (!is_committed) {
3491     commit_memory_or_exit(addr, bytes, prot == MEM_PROT_RWX,
3492                           "cannot commit protection page");
3493   }
3494   // One cannot use os::guard_memory() here, as on Win32 guard page
3495   // have different (one-shot) semantics, from MSDN on PAGE_GUARD:
3496   //
3497   // Pages in the region become guard pages. Any attempt to access a guard page
3498   // causes the system to raise a STATUS_GUARD_PAGE exception and turn off
3499   // the guard page status. Guard pages thus act as a one-time access alarm.
3500   return VirtualProtect(addr, bytes, p, &old_status) != 0;
3501 }
3502 
3503 bool os::guard_memory(char* addr, size_t bytes) {
3504   DWORD old_status;
3505   return VirtualProtect(addr, bytes, PAGE_READWRITE | PAGE_GUARD, &old_status) != 0;
3506 }
3507 
3508 bool os::unguard_memory(char* addr, size_t bytes) {
3509   DWORD old_status;
3510   return VirtualProtect(addr, bytes, PAGE_READWRITE, &old_status) != 0;
3511 }
3512 
3513 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3514 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) { }
3515 void os::numa_make_global(char *addr, size_t bytes)    { }
3516 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint)    { }
3517 bool os::numa_topology_changed()                       { return false; }
3518 size_t os::numa_get_groups_num()                       { return MAX2(numa_node_list_holder.get_count(), 1); }
3519 int os::numa_get_group_id()                            { return 0; }
3520 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
3521   if (numa_node_list_holder.get_count() == 0 && size > 0) {
3522     // Provide an answer for UMA systems
3523     ids[0] = 0;
3524     return 1;
3525   } else {
3526     // check for size bigger than actual groups_num
3527     size = MIN2(size, numa_get_groups_num());
3528     for (int i = 0; i < (int)size; i++) {
3529       ids[i] = numa_node_list_holder.get_node_list_entry(i);
3530     }
3531     return size;
3532   }
3533 }
3534 
3535 bool os::get_page_info(char *start, page_info* info) {
3536   return false;
3537 }
3538 
3539 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
3540   return end;
3541 }
3542 
3543 char* os::non_memory_address_word() {
3544   // Must never look like an address returned by reserve_memory,
3545   // even in its subfields (as defined by the CPU immediate fields,
3546   // if the CPU splits constants across multiple instructions).
3547   return (char*)-1;
3548 }
3549 
3550 #define MAX_ERROR_COUNT 100
3551 #define SYS_THREAD_ERROR 0xffffffffUL
3552 
3553 void os::pd_start_thread(Thread* thread) {
3554   DWORD ret = ResumeThread(thread->osthread()->thread_handle());
3555   // Returns previous suspend state:
3556   // 0:  Thread was not suspended
3557   // 1:  Thread is running now
3558   // >1: Thread is still suspended.
3559   assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
3560 }
3561 
3562 class HighResolutionInterval : public CHeapObj<mtThread> {
3563   // The default timer resolution seems to be 10 milliseconds.
3564   // (Where is this written down?)
3565   // If someone wants to sleep for only a fraction of the default,
3566   // then we set the timer resolution down to 1 millisecond for
3567   // the duration of their interval.
3568   // We carefully set the resolution back, since otherwise we
3569   // seem to incur an overhead (3%?) that we don't need.
3570   // CONSIDER: if ms is small, say 3, then we should run with a high resolution time.
3571   // Buf if ms is large, say 500, or 503, we should avoid the call to timeBeginPeriod().
3572   // Alternatively, we could compute the relative error (503/500 = .6%) and only use
3573   // timeBeginPeriod() if the relative error exceeded some threshold.
3574   // timeBeginPeriod() has been linked to problems with clock drift on win32 systems and
3575   // to decreased efficiency related to increased timer "tick" rates.  We want to minimize
3576   // (a) calls to timeBeginPeriod() and timeEndPeriod() and (b) time spent with high
3577   // resolution timers running.
3578 private:
3579     jlong resolution;
3580 public:
3581   HighResolutionInterval(jlong ms) {
3582     resolution = ms % 10L;
3583     if (resolution != 0) {
3584       MMRESULT result = timeBeginPeriod(1L);
3585     }
3586   }
3587   ~HighResolutionInterval() {
3588     if (resolution != 0) {
3589       MMRESULT result = timeEndPeriod(1L);
3590     }
3591     resolution = 0L;
3592   }
3593 };
3594 
3595 int os::sleep(Thread* thread, jlong ms, bool interruptable) {
3596   jlong limit = (jlong) MAXDWORD;
3597 
3598   while(ms > limit) {
3599     int res;
3600     if ((res = sleep(thread, limit, interruptable)) != OS_TIMEOUT)
3601       return res;
3602     ms -= limit;
3603   }
3604 
3605   assert(thread == Thread::current(),  "thread consistency check");
3606   OSThread* osthread = thread->osthread();
3607   OSThreadWaitState osts(osthread, false /* not Object.wait() */);
3608   int result;
3609   if (interruptable) {
3610     assert(thread->is_Java_thread(), "must be java thread");
3611     JavaThread *jt = (JavaThread *) thread;
3612     ThreadBlockInVM tbivm(jt);
3613 
3614     jt->set_suspend_equivalent();
3615     // cleared by handle_special_suspend_equivalent_condition() or
3616     // java_suspend_self() via check_and_wait_while_suspended()
3617 
3618     HANDLE events[1];
3619     events[0] = osthread->interrupt_event();
3620     HighResolutionInterval *phri=NULL;
3621     if(!ForceTimeHighResolution)
3622       phri = new HighResolutionInterval( ms );
3623     if (WaitForMultipleObjects(1, events, FALSE, (DWORD)ms) == WAIT_TIMEOUT) {
3624       result = OS_TIMEOUT;
3625     } else {
3626       ResetEvent(osthread->interrupt_event());
3627       osthread->set_interrupted(false);
3628       result = OS_INTRPT;
3629     }
3630     delete phri; //if it is NULL, harmless
3631 
3632     // were we externally suspended while we were waiting?
3633     jt->check_and_wait_while_suspended();
3634   } else {
3635     assert(!thread->is_Java_thread(), "must not be java thread");
3636     Sleep((long) ms);
3637     result = OS_TIMEOUT;
3638   }
3639   return result;
3640 }
3641 
3642 //
3643 // Short sleep, direct OS call.
3644 //
3645 // ms = 0, means allow others (if any) to run.
3646 //
3647 void os::naked_short_sleep(jlong ms) {
3648   assert(ms < 1000, "Un-interruptable sleep, short time use only");
3649   Sleep(ms);
3650 }
3651 
3652 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3653 void os::infinite_sleep() {
3654   while (true) {    // sleep forever ...
3655     Sleep(100000);  // ... 100 seconds at a time
3656   }
3657 }
3658 
3659 typedef BOOL (WINAPI * STTSignature)(void) ;
3660 
3661 os::YieldResult os::NakedYield() {
3662   // Use either SwitchToThread() or Sleep(0)
3663   // Consider passing back the return value from SwitchToThread().
3664   if (os::Kernel32Dll::SwitchToThreadAvailable()) {
3665     return SwitchToThread() ? os::YIELD_SWITCHED : os::YIELD_NONEREADY ;
3666   } else {
3667     Sleep(0);
3668   }
3669   return os::YIELD_UNKNOWN ;
3670 }
3671 
3672 void os::yield() {  os::NakedYield(); }
3673 
3674 void os::yield_all(int attempts) {
3675   // Yields to all threads, including threads with lower priorities
3676   Sleep(1);
3677 }
3678 
3679 // Win32 only gives you access to seven real priorities at a time,
3680 // so we compress Java's ten down to seven.  It would be better
3681 // if we dynamically adjusted relative priorities.
3682 
3683 int os::java_to_os_priority[CriticalPriority + 1] = {
3684   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3685   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3686   THREAD_PRIORITY_LOWEST,                       // 2
3687   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3688   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3689   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3690   THREAD_PRIORITY_NORMAL,                       // 6
3691   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3692   THREAD_PRIORITY_ABOVE_NORMAL,                 // 8
3693   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3694   THREAD_PRIORITY_HIGHEST,                      // 10 MaxPriority
3695   THREAD_PRIORITY_HIGHEST                       // 11 CriticalPriority
3696 };
3697 
3698 int prio_policy1[CriticalPriority + 1] = {
3699   THREAD_PRIORITY_IDLE,                         // 0  Entry should never be used
3700   THREAD_PRIORITY_LOWEST,                       // 1  MinPriority
3701   THREAD_PRIORITY_LOWEST,                       // 2
3702   THREAD_PRIORITY_BELOW_NORMAL,                 // 3
3703   THREAD_PRIORITY_BELOW_NORMAL,                 // 4
3704   THREAD_PRIORITY_NORMAL,                       // 5  NormPriority
3705   THREAD_PRIORITY_ABOVE_NORMAL,                 // 6
3706   THREAD_PRIORITY_ABOVE_NORMAL,                 // 7
3707   THREAD_PRIORITY_HIGHEST,                      // 8
3708   THREAD_PRIORITY_HIGHEST,                      // 9  NearMaxPriority
3709   THREAD_PRIORITY_TIME_CRITICAL,                // 10 MaxPriority
3710   THREAD_PRIORITY_TIME_CRITICAL                 // 11 CriticalPriority
3711 };
3712 
3713 static int prio_init() {
3714   // If ThreadPriorityPolicy is 1, switch tables
3715   if (ThreadPriorityPolicy == 1) {
3716     int i;
3717     for (i = 0; i < CriticalPriority + 1; i++) {
3718       os::java_to_os_priority[i] = prio_policy1[i];
3719     }
3720   }
3721   if (UseCriticalJavaThreadPriority) {
3722     os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority] ;
3723   }
3724   return 0;
3725 }
3726 
3727 OSReturn os::set_native_priority(Thread* thread, int priority) {
3728   if (!UseThreadPriorities) return OS_OK;
3729   bool ret = SetThreadPriority(thread->osthread()->thread_handle(), priority) != 0;
3730   return ret ? OS_OK : OS_ERR;
3731 }
3732 
3733 OSReturn os::get_native_priority(const Thread* const thread, int* priority_ptr) {
3734   if ( !UseThreadPriorities ) {
3735     *priority_ptr = java_to_os_priority[NormPriority];
3736     return OS_OK;
3737   }
3738   int os_prio = GetThreadPriority(thread->osthread()->thread_handle());
3739   if (os_prio == THREAD_PRIORITY_ERROR_RETURN) {
3740     assert(false, "GetThreadPriority failed");
3741     return OS_ERR;
3742   }
3743   *priority_ptr = os_prio;
3744   return OS_OK;
3745 }
3746 
3747 
3748 // Hint to the underlying OS that a task switch would not be good.
3749 // Void return because it's a hint and can fail.
3750 void os::hint_no_preempt() {}
3751 
3752 void os::interrupt(Thread* thread) {
3753   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3754          "possibility of dangling Thread pointer");
3755 
3756   OSThread* osthread = thread->osthread();
3757   osthread->set_interrupted(true);
3758   // More than one thread can get here with the same value of osthread,
3759   // resulting in multiple notifications.  We do, however, want the store
3760   // to interrupted() to be visible to other threads before we post
3761   // the interrupt event.
3762   OrderAccess::release();
3763   SetEvent(osthread->interrupt_event());
3764   // For JSR166:  unpark after setting status
3765   if (thread->is_Java_thread())
3766     ((JavaThread*)thread)->parker()->unpark();
3767 
3768   ParkEvent * ev = thread->_ParkEvent ;
3769   if (ev != NULL) ev->unpark() ;
3770 
3771 }
3772 
3773 
3774 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
3775   assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
3776          "possibility of dangling Thread pointer");
3777 
3778   OSThread* osthread = thread->osthread();
3779   // There is no synchronization between the setting of the interrupt
3780   // and it being cleared here. It is critical - see 6535709 - that
3781   // we only clear the interrupt state, and reset the interrupt event,
3782   // if we are going to report that we were indeed interrupted - else
3783   // an interrupt can be "lost", leading to spurious wakeups or lost wakeups
3784   // depending on the timing. By checking thread interrupt event to see
3785   // if the thread gets real interrupt thus prevent spurious wakeup.
3786   bool interrupted = osthread->interrupted() && (WaitForSingleObject(osthread->interrupt_event(), 0) == WAIT_OBJECT_0);
3787   if (interrupted && clear_interrupted) {
3788     osthread->set_interrupted(false);
3789     ResetEvent(osthread->interrupt_event());
3790   } // Otherwise leave the interrupted state alone
3791 
3792   return interrupted;
3793 }
3794 
3795 // Get's a pc (hint) for a running thread. Currently used only for profiling.
3796 ExtendedPC os::get_thread_pc(Thread* thread) {
3797   CONTEXT context;
3798   context.ContextFlags = CONTEXT_CONTROL;
3799   HANDLE handle = thread->osthread()->thread_handle();
3800 #ifdef _M_IA64
3801   assert(0, "Fix get_thread_pc");
3802   return ExtendedPC(NULL);
3803 #else
3804   if (GetThreadContext(handle, &context)) {
3805 #ifdef _M_AMD64
3806     return ExtendedPC((address) context.Rip);
3807 #else
3808     return ExtendedPC((address) context.Eip);
3809 #endif
3810   } else {
3811     return ExtendedPC(NULL);
3812   }
3813 #endif
3814 }
3815 
3816 // GetCurrentThreadId() returns DWORD
3817 intx os::current_thread_id()          { return GetCurrentThreadId(); }
3818 
3819 static int _initial_pid = 0;
3820 
3821 int os::current_process_id()
3822 {
3823   return (_initial_pid ? _initial_pid : _getpid());
3824 }
3825 
3826 int    os::win32::_vm_page_size       = 0;
3827 int    os::win32::_vm_allocation_granularity = 0;
3828 int    os::win32::_processor_type     = 0;
3829 // Processor level is not available on non-NT systems, use vm_version instead
3830 int    os::win32::_processor_level    = 0;
3831 julong os::win32::_physical_memory    = 0;
3832 size_t os::win32::_default_stack_size = 0;
3833 
3834          intx os::win32::_os_thread_limit    = 0;
3835 volatile intx os::win32::_os_thread_count    = 0;
3836 
3837 bool   os::win32::_is_nt              = false;
3838 bool   os::win32::_is_windows_2003    = false;
3839 bool   os::win32::_is_windows_server  = false;
3840 
3841 void os::win32::initialize_system_info() {
3842   SYSTEM_INFO si;
3843   GetSystemInfo(&si);
3844   _vm_page_size    = si.dwPageSize;
3845   _vm_allocation_granularity = si.dwAllocationGranularity;
3846   _processor_type  = si.dwProcessorType;
3847   _processor_level = si.wProcessorLevel;
3848   set_processor_count(si.dwNumberOfProcessors);
3849 
3850   MEMORYSTATUSEX ms;
3851   ms.dwLength = sizeof(ms);
3852 
3853   // also returns dwAvailPhys (free physical memory bytes), dwTotalVirtual, dwAvailVirtual,
3854   // dwMemoryLoad (% of memory in use)
3855   GlobalMemoryStatusEx(&ms);
3856   _physical_memory = ms.ullTotalPhys;
3857 
3858   OSVERSIONINFOEX oi;
3859   oi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
3860   GetVersionEx((OSVERSIONINFO*)&oi);
3861   switch(oi.dwPlatformId) {
3862     case VER_PLATFORM_WIN32_WINDOWS: _is_nt = false; break;
3863     case VER_PLATFORM_WIN32_NT:
3864       _is_nt = true;
3865       {
3866         int os_vers = oi.dwMajorVersion * 1000 + oi.dwMinorVersion;
3867         if (os_vers == 5002) {
3868           _is_windows_2003 = true;
3869         }
3870         if (oi.wProductType == VER_NT_DOMAIN_CONTROLLER ||
3871           oi.wProductType == VER_NT_SERVER) {
3872             _is_windows_server = true;
3873         }
3874       }
3875       break;
3876     default: fatal("Unknown platform");
3877   }
3878 
3879   _default_stack_size = os::current_stack_size();
3880   assert(_default_stack_size > (size_t) _vm_page_size, "invalid stack size");
3881   assert((_default_stack_size & (_vm_page_size - 1)) == 0,
3882     "stack size not a multiple of page size");
3883 
3884   initialize_performance_counter();
3885 
3886   // Win95/Win98 scheduler bug work-around. The Win95/98 scheduler is
3887   // known to deadlock the system, if the VM issues to thread operations with
3888   // a too high frequency, e.g., such as changing the priorities.
3889   // The 6000 seems to work well - no deadlocks has been notices on the test
3890   // programs that we have seen experience this problem.
3891   if (!os::win32::is_nt()) {
3892     StarvationMonitorInterval = 6000;
3893   }
3894 }
3895 
3896 
3897 HINSTANCE os::win32::load_Windows_dll(const char* name, char *ebuf, int ebuflen) {
3898   char path[MAX_PATH];
3899   DWORD size;
3900   DWORD pathLen = (DWORD)sizeof(path);
3901   HINSTANCE result = NULL;
3902 
3903   // only allow library name without path component
3904   assert(strchr(name, '\\') == NULL, "path not allowed");
3905   assert(strchr(name, ':') == NULL, "path not allowed");
3906   if (strchr(name, '\\') != NULL || strchr(name, ':') != NULL) {
3907     jio_snprintf(ebuf, ebuflen,
3908       "Invalid parameter while calling os::win32::load_windows_dll(): cannot take path: %s", name);
3909     return NULL;
3910   }
3911 
3912   // search system directory
3913   if ((size = GetSystemDirectory(path, pathLen)) > 0) {
3914     strcat(path, "\\");
3915     strcat(path, name);
3916     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3917       return result;
3918     }
3919   }
3920 
3921   // try Windows directory
3922   if ((size = GetWindowsDirectory(path, pathLen)) > 0) {
3923     strcat(path, "\\");
3924     strcat(path, name);
3925     if ((result = (HINSTANCE)os::dll_load(path, ebuf, ebuflen)) != NULL) {
3926       return result;
3927     }
3928   }
3929 
3930   jio_snprintf(ebuf, ebuflen,
3931     "os::win32::load_windows_dll() cannot load %s from system directories.", name);
3932   return NULL;
3933 }
3934 
3935 void os::win32::setmode_streams() {
3936   _setmode(_fileno(stdin), _O_BINARY);
3937   _setmode(_fileno(stdout), _O_BINARY);
3938   _setmode(_fileno(stderr), _O_BINARY);
3939 }
3940 
3941 
3942 bool os::is_debugger_attached() {
3943   return IsDebuggerPresent() ? true : false;
3944 }
3945 
3946 
3947 void os::wait_for_keypress_at_exit(void) {
3948   if (PauseAtExit) {
3949     fprintf(stderr, "Press any key to continue...\n");
3950     fgetc(stdin);
3951   }
3952 }
3953 
3954 
3955 int os::message_box(const char* title, const char* message) {
3956   int result = MessageBox(NULL, message, title,
3957                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
3958   return result == IDYES;
3959 }
3960 
3961 int os::allocate_thread_local_storage() {
3962   return TlsAlloc();
3963 }
3964 
3965 
3966 void os::free_thread_local_storage(int index) {
3967   TlsFree(index);
3968 }
3969 
3970 
3971 void os::thread_local_storage_at_put(int index, void* value) {
3972   TlsSetValue(index, value);
3973   assert(thread_local_storage_at(index) == value, "Just checking");
3974 }
3975 
3976 
3977 void* os::thread_local_storage_at(int index) {
3978   return TlsGetValue(index);
3979 }
3980 
3981 
3982 #ifndef PRODUCT
3983 #ifndef _WIN64
3984 // Helpers to check whether NX protection is enabled
3985 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
3986   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
3987       pex->ExceptionRecord->NumberParameters > 0 &&
3988       pex->ExceptionRecord->ExceptionInformation[0] ==
3989       EXCEPTION_INFO_EXEC_VIOLATION) {
3990     return EXCEPTION_EXECUTE_HANDLER;
3991   }
3992   return EXCEPTION_CONTINUE_SEARCH;
3993 }
3994 
3995 void nx_check_protection() {
3996   // If NX is enabled we'll get an exception calling into code on the stack
3997   char code[] = { (char)0xC3 }; // ret
3998   void *code_ptr = (void *)code;
3999   __try {
4000     __asm call code_ptr
4001   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
4002     tty->print_raw_cr("NX protection detected.");
4003   }
4004 }
4005 #endif // _WIN64
4006 #endif // PRODUCT
4007 
4008 // this is called _before_ the global arguments have been parsed
4009 void os::init(void) {
4010   _initial_pid = _getpid();
4011 
4012   init_random(1234567);
4013 
4014   win32::initialize_system_info();
4015   win32::setmode_streams();
4016   init_page_sizes((size_t) win32::vm_page_size());
4017 
4018   // For better scalability on MP systems (must be called after initialize_system_info)
4019 #ifndef PRODUCT
4020   if (is_MP()) {
4021     NoYieldsInMicrolock = true;
4022   }
4023 #endif
4024   // This may be overridden later when argument processing is done.
4025   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
4026     os::win32::is_windows_2003());
4027 
4028   // Initialize main_process and main_thread
4029   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
4030  if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
4031                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
4032     fatal("DuplicateHandle failed\n");
4033   }
4034   main_thread_id = (int) GetCurrentThreadId();
4035 }
4036 
4037 // To install functions for atexit processing
4038 extern "C" {
4039   static void perfMemory_exit_helper() {
4040     perfMemory_exit();
4041   }
4042 }
4043 
4044 static jint initSock();
4045 
4046 // this is called _after_ the global arguments have been parsed
4047 jint os::init_2(void) {
4048   // Allocate a single page and mark it as readable for safepoint polling
4049   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
4050   guarantee( polling_page != NULL, "Reserve Failed for polling page");
4051 
4052   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
4053   guarantee( return_page != NULL, "Commit Failed for polling page");
4054 
4055   os::set_polling_page( polling_page );
4056 
4057 #ifndef PRODUCT
4058   if( Verbose && PrintMiscellaneous )
4059     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
4060 #endif
4061 
4062   if (!UseMembar) {
4063     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
4064     guarantee( mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
4065 
4066     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
4067     guarantee( return_page != NULL, "Commit Failed for memory serialize page");
4068 
4069     os::set_memory_serialize_page( mem_serialize_page );
4070 
4071 #ifndef PRODUCT
4072     if(Verbose && PrintMiscellaneous)
4073       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
4074 #endif
4075   }
4076 
4077   // Setup Windows Exceptions
4078 
4079   // for debugging float code generation bugs
4080   if (ForceFloatExceptions) {
4081 #ifndef  _WIN64
4082     static long fp_control_word = 0;
4083     __asm { fstcw fp_control_word }
4084     // see Intel PPro Manual, Vol. 2, p 7-16
4085     const long precision = 0x20;
4086     const long underflow = 0x10;
4087     const long overflow  = 0x08;
4088     const long zero_div  = 0x04;
4089     const long denorm    = 0x02;
4090     const long invalid   = 0x01;
4091     fp_control_word |= invalid;
4092     __asm { fldcw fp_control_word }
4093 #endif
4094   }
4095 
4096   // If stack_commit_size is 0, windows will reserve the default size,
4097   // but only commit a small portion of it.
4098   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
4099   size_t default_reserve_size = os::win32::default_stack_size();
4100   size_t actual_reserve_size = stack_commit_size;
4101   if (stack_commit_size < default_reserve_size) {
4102     // If stack_commit_size == 0, we want this too
4103     actual_reserve_size = default_reserve_size;
4104   }
4105 
4106   // Check minimum allowable stack size for thread creation and to initialize
4107   // the java system classes, including StackOverflowError - depends on page
4108   // size.  Add a page for compiler2 recursion in main thread.
4109   // Add in 2*BytesPerWord times page size to account for VM stack during
4110   // class initialization depending on 32 or 64 bit VM.
4111   size_t min_stack_allowed =
4112             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4113             2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
4114   if (actual_reserve_size < min_stack_allowed) {
4115     tty->print_cr("\nThe stack size specified is too small, "
4116                   "Specify at least %dk",
4117                   min_stack_allowed / K);
4118     return JNI_ERR;
4119   }
4120 
4121   JavaThread::set_stack_size_at_create(stack_commit_size);
4122 
4123   // Calculate theoretical max. size of Threads to guard gainst artifical
4124   // out-of-memory situations, where all available address-space has been
4125   // reserved by thread stacks.
4126   assert(actual_reserve_size != 0, "Must have a stack");
4127 
4128   // Calculate the thread limit when we should start doing Virtual Memory
4129   // banging. Currently when the threads will have used all but 200Mb of space.
4130   //
4131   // TODO: consider performing a similar calculation for commit size instead
4132   // as reserve size, since on a 64-bit platform we'll run into that more
4133   // often than running out of virtual memory space.  We can use the
4134   // lower value of the two calculations as the os_thread_limit.
4135   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
4136   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
4137 
4138   // at exit methods are called in the reverse order of their registration.
4139   // there is no limit to the number of functions registered. atexit does
4140   // not set errno.
4141 
4142   if (PerfAllowAtExitRegistration) {
4143     // only register atexit functions if PerfAllowAtExitRegistration is set.
4144     // atexit functions can be delayed until process exit time, which
4145     // can be problematic for embedded VM situations. Embedded VMs should
4146     // call DestroyJavaVM() to assure that VM resources are released.
4147 
4148     // note: perfMemory_exit_helper atexit function may be removed in
4149     // the future if the appropriate cleanup code can be added to the
4150     // VM_Exit VMOperation's doit method.
4151     if (atexit(perfMemory_exit_helper) != 0) {
4152       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4153     }
4154   }
4155 
4156 #ifndef _WIN64
4157   // Print something if NX is enabled (win32 on AMD64)
4158   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4159 #endif
4160 
4161   // initialize thread priority policy
4162   prio_init();
4163 
4164   if (UseNUMA && !ForceNUMA) {
4165     UseNUMA = false; // We don't fully support this yet
4166   }
4167 
4168   if (UseNUMAInterleaving) {
4169     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4170     bool success = numa_interleaving_init();
4171     if (!success) UseNUMAInterleaving = false;
4172   }
4173 
4174   if (initSock() != JNI_OK) {
4175     return JNI_ERR;
4176   }
4177 
4178   return JNI_OK;
4179 }
4180 
4181 // Mark the polling page as unreadable
4182 void os::make_polling_page_unreadable(void) {
4183   DWORD old_status;
4184   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_NOACCESS, &old_status) )
4185     fatal("Could not disable polling page");
4186 };
4187 
4188 // Mark the polling page as readable
4189 void os::make_polling_page_readable(void) {
4190   DWORD old_status;
4191   if( !VirtualProtect((char *)_polling_page, os::vm_page_size(), PAGE_READONLY, &old_status) )
4192     fatal("Could not enable polling page");
4193 };
4194 
4195 
4196 int os::stat(const char *path, struct stat *sbuf) {
4197   char pathbuf[MAX_PATH];
4198   if (strlen(path) > MAX_PATH - 1) {
4199     errno = ENAMETOOLONG;
4200     return -1;
4201   }
4202   os::native_path(strcpy(pathbuf, path));
4203   int ret = ::stat(pathbuf, sbuf);
4204   if (sbuf != NULL && UseUTCFileTimestamp) {
4205     // Fix for 6539723.  st_mtime returned from stat() is dependent on
4206     // the system timezone and so can return different values for the
4207     // same file if/when daylight savings time changes.  This adjustment
4208     // makes sure the same timestamp is returned regardless of the TZ.
4209     //
4210     // See:
4211     // http://msdn.microsoft.com/library/
4212     //   default.asp?url=/library/en-us/sysinfo/base/
4213     //   time_zone_information_str.asp
4214     // and
4215     // http://msdn.microsoft.com/library/default.asp?url=
4216     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
4217     //
4218     // NOTE: there is a insidious bug here:  If the timezone is changed
4219     // after the call to stat() but before 'GetTimeZoneInformation()', then
4220     // the adjustment we do here will be wrong and we'll return the wrong
4221     // value (which will likely end up creating an invalid class data
4222     // archive).  Absent a better API for this, or some time zone locking
4223     // mechanism, we'll have to live with this risk.
4224     TIME_ZONE_INFORMATION tz;
4225     DWORD tzid = GetTimeZoneInformation(&tz);
4226     int daylightBias =
4227       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
4228     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
4229   }
4230   return ret;
4231 }
4232 
4233 
4234 #define FT2INT64(ft) \
4235   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4236 
4237 
4238 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4239 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4240 // of a thread.
4241 //
4242 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4243 // the fast estimate available on the platform.
4244 
4245 // current_thread_cpu_time() is not optimized for Windows yet
4246 jlong os::current_thread_cpu_time() {
4247   // return user + sys since the cost is the same
4248   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4249 }
4250 
4251 jlong os::thread_cpu_time(Thread* thread) {
4252   // consistent with what current_thread_cpu_time() returns.
4253   return os::thread_cpu_time(thread, true /* user+sys */);
4254 }
4255 
4256 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4257   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4258 }
4259 
4260 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4261   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4262   // If this function changes, os::is_thread_cpu_time_supported() should too
4263   if (os::win32::is_nt()) {
4264     FILETIME CreationTime;
4265     FILETIME ExitTime;
4266     FILETIME KernelTime;
4267     FILETIME UserTime;
4268 
4269     if ( GetThreadTimes(thread->osthread()->thread_handle(),
4270                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4271       return -1;
4272     else
4273       if (user_sys_cpu_time) {
4274         return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4275       } else {
4276         return FT2INT64(UserTime) * 100;
4277       }
4278   } else {
4279     return (jlong) timeGetTime() * 1000000;
4280   }
4281 }
4282 
4283 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4284   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4285   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4286   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4287   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4288 }
4289 
4290 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4291   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4292   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4293   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4294   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4295 }
4296 
4297 bool os::is_thread_cpu_time_supported() {
4298   // see os::thread_cpu_time
4299   if (os::win32::is_nt()) {
4300     FILETIME CreationTime;
4301     FILETIME ExitTime;
4302     FILETIME KernelTime;
4303     FILETIME UserTime;
4304 
4305     if ( GetThreadTimes(GetCurrentThread(),
4306                     &CreationTime, &ExitTime, &KernelTime, &UserTime) == 0)
4307       return false;
4308     else
4309       return true;
4310   } else {
4311     return false;
4312   }
4313 }
4314 
4315 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4316 // It does have primitives (PDH API) to get CPU usage and run queue length.
4317 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4318 // If we wanted to implement loadavg on Windows, we have a few options:
4319 //
4320 // a) Query CPU usage and run queue length and "fake" an answer by
4321 //    returning the CPU usage if it's under 100%, and the run queue
4322 //    length otherwise.  It turns out that querying is pretty slow
4323 //    on Windows, on the order of 200 microseconds on a fast machine.
4324 //    Note that on the Windows the CPU usage value is the % usage
4325 //    since the last time the API was called (and the first call
4326 //    returns 100%), so we'd have to deal with that as well.
4327 //
4328 // b) Sample the "fake" answer using a sampling thread and store
4329 //    the answer in a global variable.  The call to loadavg would
4330 //    just return the value of the global, avoiding the slow query.
4331 //
4332 // c) Sample a better answer using exponential decay to smooth the
4333 //    value.  This is basically the algorithm used by UNIX kernels.
4334 //
4335 // Note that sampling thread starvation could affect both (b) and (c).
4336 int os::loadavg(double loadavg[], int nelem) {
4337   return -1;
4338 }
4339 
4340 
4341 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4342 bool os::dont_yield() {
4343   return DontYieldALot;
4344 }
4345 
4346 // This method is a slightly reworked copy of JDK's sysOpen
4347 // from src/windows/hpi/src/sys_api_md.c
4348 
4349 int os::open(const char *path, int oflag, int mode) {
4350   char pathbuf[MAX_PATH];
4351 
4352   if (strlen(path) > MAX_PATH - 1) {
4353     errno = ENAMETOOLONG;
4354           return -1;
4355   }
4356   os::native_path(strcpy(pathbuf, path));
4357   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4358 }
4359 
4360 FILE* os::open(int fd, const char* mode) {
4361   return ::_fdopen(fd, mode);
4362 }
4363 
4364 // Is a (classpath) directory empty?
4365 bool os::dir_is_empty(const char* path) {
4366   WIN32_FIND_DATA fd;
4367   HANDLE f = FindFirstFile(path, &fd);
4368   if (f == INVALID_HANDLE_VALUE) {
4369     return true;
4370   }
4371   FindClose(f);
4372   return false;
4373 }
4374 
4375 // create binary file, rewriting existing file if required
4376 int os::create_binary_file(const char* path, bool rewrite_existing) {
4377   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4378   if (!rewrite_existing) {
4379     oflags |= _O_EXCL;
4380   }
4381   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4382 }
4383 
4384 // return current position of file pointer
4385 jlong os::current_file_offset(int fd) {
4386   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4387 }
4388 
4389 // move file pointer to the specified offset
4390 jlong os::seek_to_file_offset(int fd, jlong offset) {
4391   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4392 }
4393 
4394 
4395 jlong os::lseek(int fd, jlong offset, int whence) {
4396   return (jlong) ::_lseeki64(fd, offset, whence);
4397 }
4398 
4399 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
4400   OVERLAPPED ov;
4401   DWORD nread;
4402   BOOL result;
4403 
4404   ZeroMemory(&ov, sizeof(ov));
4405   ov.Offset = (DWORD)offset;
4406   ov.OffsetHigh = (DWORD)(offset >> 32);
4407 
4408   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4409 
4410   result = ReadFile(h, (LPVOID)buf, nBytes, &nread, &ov);
4411 
4412   return result ? nread : 0;
4413 }
4414 
4415 // This method is a slightly reworked copy of JDK's sysNativePath
4416 // from src/windows/hpi/src/path_md.c
4417 
4418 /* Convert a pathname to native format.  On win32, this involves forcing all
4419    separators to be '\\' rather than '/' (both are legal inputs, but Win95
4420    sometimes rejects '/') and removing redundant separators.  The input path is
4421    assumed to have been converted into the character encoding used by the local
4422    system.  Because this might be a double-byte encoding, care is taken to
4423    treat double-byte lead characters correctly.
4424 
4425    This procedure modifies the given path in place, as the result is never
4426    longer than the original.  There is no error return; this operation always
4427    succeeds. */
4428 char * os::native_path(char *path) {
4429   char *src = path, *dst = path, *end = path;
4430   char *colon = NULL;           /* If a drive specifier is found, this will
4431                                         point to the colon following the drive
4432                                         letter */
4433 
4434   /* Assumption: '/', '\\', ':', and drive letters are never lead bytes */
4435   assert(((!::IsDBCSLeadByte('/'))
4436     && (!::IsDBCSLeadByte('\\'))
4437     && (!::IsDBCSLeadByte(':'))),
4438     "Illegal lead byte");
4439 
4440   /* Check for leading separators */
4441 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4442   while (isfilesep(*src)) {
4443     src++;
4444   }
4445 
4446   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4447     /* Remove leading separators if followed by drive specifier.  This
4448       hack is necessary to support file URLs containing drive
4449       specifiers (e.g., "file://c:/path").  As a side effect,
4450       "/c:/path" can be used as an alternative to "c:/path". */
4451     *dst++ = *src++;
4452     colon = dst;
4453     *dst++ = ':';
4454     src++;
4455   } else {
4456     src = path;
4457     if (isfilesep(src[0]) && isfilesep(src[1])) {
4458       /* UNC pathname: Retain first separator; leave src pointed at
4459          second separator so that further separators will be collapsed
4460          into the second separator.  The result will be a pathname
4461          beginning with "\\\\" followed (most likely) by a host name. */
4462       src = dst = path + 1;
4463       path[0] = '\\';     /* Force first separator to '\\' */
4464     }
4465   }
4466 
4467   end = dst;
4468 
4469   /* Remove redundant separators from remainder of path, forcing all
4470       separators to be '\\' rather than '/'. Also, single byte space
4471       characters are removed from the end of the path because those
4472       are not legal ending characters on this operating system.
4473   */
4474   while (*src != '\0') {
4475     if (isfilesep(*src)) {
4476       *dst++ = '\\'; src++;
4477       while (isfilesep(*src)) src++;
4478       if (*src == '\0') {
4479         /* Check for trailing separator */
4480         end = dst;
4481         if (colon == dst - 2) break;                      /* "z:\\" */
4482         if (dst == path + 1) break;                       /* "\\" */
4483         if (dst == path + 2 && isfilesep(path[0])) {
4484           /* "\\\\" is not collapsed to "\\" because "\\\\" marks the
4485             beginning of a UNC pathname.  Even though it is not, by
4486             itself, a valid UNC pathname, we leave it as is in order
4487             to be consistent with the path canonicalizer as well
4488             as the win32 APIs, which treat this case as an invalid
4489             UNC pathname rather than as an alias for the root
4490             directory of the current drive. */
4491           break;
4492         }
4493         end = --dst;  /* Path does not denote a root directory, so
4494                                     remove trailing separator */
4495         break;
4496       }
4497       end = dst;
4498     } else {
4499       if (::IsDBCSLeadByte(*src)) { /* Copy a double-byte character */
4500         *dst++ = *src++;
4501         if (*src) *dst++ = *src++;
4502         end = dst;
4503       } else {         /* Copy a single-byte character */
4504         char c = *src++;
4505         *dst++ = c;
4506         /* Space is not a legal ending character */
4507         if (c != ' ') end = dst;
4508       }
4509     }
4510   }
4511 
4512   *end = '\0';
4513 
4514   /* For "z:", add "." to work around a bug in the C runtime library */
4515   if (colon == dst - 1) {
4516           path[2] = '.';
4517           path[3] = '\0';
4518   }
4519 
4520   return path;
4521 }
4522 
4523 // This code is a copy of JDK's sysSetLength
4524 // from src/windows/hpi/src/sys_api_md.c
4525 
4526 int os::ftruncate(int fd, jlong length) {
4527   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4528   long high = (long)(length >> 32);
4529   DWORD ret;
4530 
4531   if (h == (HANDLE)(-1)) {
4532     return -1;
4533   }
4534 
4535   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4536   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4537       return -1;
4538   }
4539 
4540   if (::SetEndOfFile(h) == FALSE) {
4541     return -1;
4542   }
4543 
4544   return 0;
4545 }
4546 
4547 
4548 // This code is a copy of JDK's sysSync
4549 // from src/windows/hpi/src/sys_api_md.c
4550 // except for the legacy workaround for a bug in Win 98
4551 
4552 int os::fsync(int fd) {
4553   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4554 
4555   if ( (!::FlushFileBuffers(handle)) &&
4556          (GetLastError() != ERROR_ACCESS_DENIED) ) {
4557     /* from winerror.h */
4558     return -1;
4559   }
4560   return 0;
4561 }
4562 
4563 static int nonSeekAvailable(int, long *);
4564 static int stdinAvailable(int, long *);
4565 
4566 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4567 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4568 
4569 // This code is a copy of JDK's sysAvailable
4570 // from src/windows/hpi/src/sys_api_md.c
4571 
4572 int os::available(int fd, jlong *bytes) {
4573   jlong cur, end;
4574   struct _stati64 stbuf64;
4575 
4576   if (::_fstati64(fd, &stbuf64) >= 0) {
4577     int mode = stbuf64.st_mode;
4578     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4579       int ret;
4580       long lpbytes;
4581       if (fd == 0) {
4582         ret = stdinAvailable(fd, &lpbytes);
4583       } else {
4584         ret = nonSeekAvailable(fd, &lpbytes);
4585       }
4586       (*bytes) = (jlong)(lpbytes);
4587       return ret;
4588     }
4589     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4590       return FALSE;
4591     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4592       return FALSE;
4593     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4594       return FALSE;
4595     }
4596     *bytes = end - cur;
4597     return TRUE;
4598   } else {
4599     return FALSE;
4600   }
4601 }
4602 
4603 // This code is a copy of JDK's nonSeekAvailable
4604 // from src/windows/hpi/src/sys_api_md.c
4605 
4606 static int nonSeekAvailable(int fd, long *pbytes) {
4607   /* This is used for available on non-seekable devices
4608     * (like both named and anonymous pipes, such as pipes
4609     *  connected to an exec'd process).
4610     * Standard Input is a special case.
4611     *
4612     */
4613   HANDLE han;
4614 
4615   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4616     return FALSE;
4617   }
4618 
4619   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4620         /* PeekNamedPipe fails when at EOF.  In that case we
4621          * simply make *pbytes = 0 which is consistent with the
4622          * behavior we get on Solaris when an fd is at EOF.
4623          * The only alternative is to raise an Exception,
4624          * which isn't really warranted.
4625          */
4626     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4627       return FALSE;
4628     }
4629     *pbytes = 0;
4630   }
4631   return TRUE;
4632 }
4633 
4634 #define MAX_INPUT_EVENTS 2000
4635 
4636 // This code is a copy of JDK's stdinAvailable
4637 // from src/windows/hpi/src/sys_api_md.c
4638 
4639 static int stdinAvailable(int fd, long *pbytes) {
4640   HANDLE han;
4641   DWORD numEventsRead = 0;      /* Number of events read from buffer */
4642   DWORD numEvents = 0;  /* Number of events in buffer */
4643   DWORD i = 0;          /* Loop index */
4644   DWORD curLength = 0;  /* Position marker */
4645   DWORD actualLength = 0;       /* Number of bytes readable */
4646   BOOL error = FALSE;         /* Error holder */
4647   INPUT_RECORD *lpBuffer;     /* Pointer to records of input events */
4648 
4649   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4650         return FALSE;
4651   }
4652 
4653   /* Construct an array of input records in the console buffer */
4654   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4655   if (error == 0) {
4656     return nonSeekAvailable(fd, pbytes);
4657   }
4658 
4659   /* lpBuffer must fit into 64K or else PeekConsoleInput fails */
4660   if (numEvents > MAX_INPUT_EVENTS) {
4661     numEvents = MAX_INPUT_EVENTS;
4662   }
4663 
4664   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4665   if (lpBuffer == NULL) {
4666     return FALSE;
4667   }
4668 
4669   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4670   if (error == 0) {
4671     os::free(lpBuffer, mtInternal);
4672     return FALSE;
4673   }
4674 
4675   /* Examine input records for the number of bytes available */
4676   for(i=0; i<numEvents; i++) {
4677     if (lpBuffer[i].EventType == KEY_EVENT) {
4678 
4679       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4680                                       &(lpBuffer[i].Event);
4681       if (keyRecord->bKeyDown == TRUE) {
4682         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4683         curLength++;
4684         if (*keyPressed == '\r') {
4685           actualLength = curLength;
4686         }
4687       }
4688     }
4689   }
4690 
4691   if(lpBuffer != NULL) {
4692     os::free(lpBuffer, mtInternal);
4693   }
4694 
4695   *pbytes = (long) actualLength;
4696   return TRUE;
4697 }
4698 
4699 // Map a block of memory.
4700 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4701                      char *addr, size_t bytes, bool read_only,
4702                      bool allow_exec) {
4703   HANDLE hFile;
4704   char* base;
4705 
4706   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4707                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4708   if (hFile == NULL) {
4709     if (PrintMiscellaneous && Verbose) {
4710       DWORD err = GetLastError();
4711       tty->print_cr("CreateFile() failed: GetLastError->%ld.", err);
4712     }
4713     return NULL;
4714   }
4715 
4716   if (allow_exec) {
4717     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4718     // unless it comes from a PE image (which the shared archive is not.)
4719     // Even VirtualProtect refuses to give execute access to mapped memory
4720     // that was not previously executable.
4721     //
4722     // Instead, stick the executable region in anonymous memory.  Yuck.
4723     // Penalty is that ~4 pages will not be shareable - in the future
4724     // we might consider DLLizing the shared archive with a proper PE
4725     // header so that mapping executable + sharing is possible.
4726 
4727     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4728                                 PAGE_READWRITE);
4729     if (base == NULL) {
4730       if (PrintMiscellaneous && Verbose) {
4731         DWORD err = GetLastError();
4732         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4733       }
4734       CloseHandle(hFile);
4735       return NULL;
4736     }
4737 
4738     DWORD bytes_read;
4739     OVERLAPPED overlapped;
4740     overlapped.Offset = (DWORD)file_offset;
4741     overlapped.OffsetHigh = 0;
4742     overlapped.hEvent = NULL;
4743     // ReadFile guarantees that if the return value is true, the requested
4744     // number of bytes were read before returning.
4745     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4746     if (!res) {
4747       if (PrintMiscellaneous && Verbose) {
4748         DWORD err = GetLastError();
4749         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4750       }
4751       release_memory(base, bytes);
4752       CloseHandle(hFile);
4753       return NULL;
4754     }
4755   } else {
4756     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4757                                     NULL /*file_name*/);
4758     if (hMap == NULL) {
4759       if (PrintMiscellaneous && Verbose) {
4760         DWORD err = GetLastError();
4761         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err);
4762       }
4763       CloseHandle(hFile);
4764       return NULL;
4765     }
4766 
4767     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4768     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4769                                   (DWORD)bytes, addr);
4770     if (base == NULL) {
4771       if (PrintMiscellaneous && Verbose) {
4772         DWORD err = GetLastError();
4773         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4774       }
4775       CloseHandle(hMap);
4776       CloseHandle(hFile);
4777       return NULL;
4778     }
4779 
4780     if (CloseHandle(hMap) == 0) {
4781       if (PrintMiscellaneous && Verbose) {
4782         DWORD err = GetLastError();
4783         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4784       }
4785       CloseHandle(hFile);
4786       return base;
4787     }
4788   }
4789 
4790   if (allow_exec) {
4791     DWORD old_protect;
4792     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4793     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4794 
4795     if (!res) {
4796       if (PrintMiscellaneous && Verbose) {
4797         DWORD err = GetLastError();
4798         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4799       }
4800       // Don't consider this a hard error, on IA32 even if the
4801       // VirtualProtect fails, we should still be able to execute
4802       CloseHandle(hFile);
4803       return base;
4804     }
4805   }
4806 
4807   if (CloseHandle(hFile) == 0) {
4808     if (PrintMiscellaneous && Verbose) {
4809       DWORD err = GetLastError();
4810       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4811     }
4812     return base;
4813   }
4814 
4815   return base;
4816 }
4817 
4818 
4819 // Remap a block of memory.
4820 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4821                        char *addr, size_t bytes, bool read_only,
4822                        bool allow_exec) {
4823   // This OS does not allow existing memory maps to be remapped so we
4824   // have to unmap the memory before we remap it.
4825   if (!os::unmap_memory(addr, bytes)) {
4826     return NULL;
4827   }
4828 
4829   // There is a very small theoretical window between the unmap_memory()
4830   // call above and the map_memory() call below where a thread in native
4831   // code may be able to access an address that is no longer mapped.
4832 
4833   return os::map_memory(fd, file_name, file_offset, addr, bytes,
4834            read_only, allow_exec);
4835 }
4836 
4837 
4838 // Unmap a block of memory.
4839 // Returns true=success, otherwise false.
4840 
4841 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4842   BOOL result = UnmapViewOfFile(addr);
4843   if (result == 0) {
4844     if (PrintMiscellaneous && Verbose) {
4845       DWORD err = GetLastError();
4846       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4847     }
4848     return false;
4849   }
4850   return true;
4851 }
4852 
4853 void os::pause() {
4854   char filename[MAX_PATH];
4855   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4856     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4857   } else {
4858     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4859   }
4860 
4861   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4862   if (fd != -1) {
4863     struct stat buf;
4864     ::close(fd);
4865     while (::stat(filename, &buf) == 0) {
4866       Sleep(100);
4867     }
4868   } else {
4869     jio_fprintf(stderr,
4870       "Could not open pause file '%s', continuing immediately.\n", filename);
4871   }
4872 }
4873 
4874 Thread* os::ThreadCrashProtection::_protected_thread = NULL;
4875 os::ThreadCrashProtection* os::ThreadCrashProtection::_crash_protection = NULL;
4876 volatile intptr_t os::ThreadCrashProtection::_crash_mux = 0;
4877 
4878 os::ThreadCrashProtection::ThreadCrashProtection() {
4879 }
4880 
4881 // See the caveats for this class in os_windows.hpp
4882 // Protects the callback call so that raised OS EXCEPTIONS causes a jump back
4883 // into this method and returns false. If no OS EXCEPTION was raised, returns
4884 // true.
4885 // The callback is supposed to provide the method that should be protected.
4886 //
4887 bool os::ThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
4888 
4889   Thread::muxAcquire(&_crash_mux, "CrashProtection");
4890 
4891   _protected_thread = ThreadLocalStorage::thread();
4892   assert(_protected_thread != NULL, "Cannot crash protect a NULL thread");
4893 
4894   bool success = true;
4895   __try {
4896     _crash_protection = this;
4897     cb.call();
4898   } __except(EXCEPTION_EXECUTE_HANDLER) {
4899     // only for protection, nothing to do
4900     success = false;
4901   }
4902   _crash_protection = NULL;
4903   _protected_thread = NULL;
4904   Thread::muxRelease(&_crash_mux);
4905   return success;
4906 }
4907 
4908 // An Event wraps a win32 "CreateEvent" kernel handle.
4909 //
4910 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
4911 //
4912 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
4913 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
4914 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
4915 //     In addition, an unpark() operation might fetch the handle field, but the
4916 //     event could recycle between the fetch and the SetEvent() operation.
4917 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
4918 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
4919 //     on an stale but recycled handle would be harmless, but in practice this might
4920 //     confuse other non-Sun code, so it's not a viable approach.
4921 //
4922 // 2:  Once a win32 event handle is associated with an Event, it remains associated
4923 //     with the Event.  The event handle is never closed.  This could be construed
4924 //     as handle leakage, but only up to the maximum # of threads that have been extant
4925 //     at any one time.  This shouldn't be an issue, as windows platforms typically
4926 //     permit a process to have hundreds of thousands of open handles.
4927 //
4928 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
4929 //     and release unused handles.
4930 //
4931 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
4932 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
4933 //
4934 // 5.  Use an RCU-like mechanism (Read-Copy Update).
4935 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
4936 //
4937 // We use (2).
4938 //
4939 // TODO-FIXME:
4940 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
4941 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
4942 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
4943 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
4944 //     into a single win32 CreateEvent() handle.
4945 //
4946 // _Event transitions in park()
4947 //   -1 => -1 : illegal
4948 //    1 =>  0 : pass - return immediately
4949 //    0 => -1 : block
4950 //
4951 // _Event serves as a restricted-range semaphore :
4952 //    -1 : thread is blocked
4953 //     0 : neutral  - thread is running or ready
4954 //     1 : signaled - thread is running or ready
4955 //
4956 // Another possible encoding of _Event would be
4957 // with explicit "PARKED" and "SIGNALED" bits.
4958 
4959 int os::PlatformEvent::park (jlong Millis) {
4960     guarantee (_ParkHandle != NULL , "Invariant") ;
4961     guarantee (Millis > 0          , "Invariant") ;
4962     int v ;
4963 
4964     // CONSIDER: defer assigning a CreateEvent() handle to the Event until
4965     // the initial park() operation.
4966 
4967     for (;;) {
4968         v = _Event ;
4969         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
4970     }
4971     guarantee ((v == 0) || (v == 1), "invariant") ;
4972     if (v != 0) return OS_OK ;
4973 
4974     // Do this the hard way by blocking ...
4975     // TODO: consider a brief spin here, gated on the success of recent
4976     // spin attempts by this thread.
4977     //
4978     // We decompose long timeouts into series of shorter timed waits.
4979     // Evidently large timo values passed in WaitForSingleObject() are problematic on some
4980     // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
4981     // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
4982     // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
4983     // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
4984     // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
4985     // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
4986     // for the already waited time.  This policy does not admit any new outcomes.
4987     // In the future, however, we might want to track the accumulated wait time and
4988     // adjust Millis accordingly if we encounter a spurious wakeup.
4989 
4990     const int MAXTIMEOUT = 0x10000000 ;
4991     DWORD rv = WAIT_TIMEOUT ;
4992     while (_Event < 0 && Millis > 0) {
4993        DWORD prd = Millis ;     // set prd = MAX (Millis, MAXTIMEOUT)
4994        if (Millis > MAXTIMEOUT) {
4995           prd = MAXTIMEOUT ;
4996        }
4997        rv = ::WaitForSingleObject (_ParkHandle, prd) ;
4998        assert (rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed") ;
4999        if (rv == WAIT_TIMEOUT) {
5000            Millis -= prd ;
5001        }
5002     }
5003     v = _Event ;
5004     _Event = 0 ;
5005     // see comment at end of os::PlatformEvent::park() below:
5006     OrderAccess::fence() ;
5007     // If we encounter a nearly simultanous timeout expiry and unpark()
5008     // we return OS_OK indicating we awoke via unpark().
5009     // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
5010     return (v >= 0) ? OS_OK : OS_TIMEOUT ;
5011 }
5012 
5013 void os::PlatformEvent::park () {
5014     guarantee (_ParkHandle != NULL, "Invariant") ;
5015     // Invariant: Only the thread associated with the Event/PlatformEvent
5016     // may call park().
5017     int v ;
5018     for (;;) {
5019         v = _Event ;
5020         if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
5021     }
5022     guarantee ((v == 0) || (v == 1), "invariant") ;
5023     if (v != 0) return ;
5024 
5025     // Do this the hard way by blocking ...
5026     // TODO: consider a brief spin here, gated on the success of recent
5027     // spin attempts by this thread.
5028     while (_Event < 0) {
5029        DWORD rv = ::WaitForSingleObject (_ParkHandle, INFINITE) ;
5030        assert (rv == WAIT_OBJECT_0, "WaitForSingleObject failed") ;
5031     }
5032 
5033     // Usually we'll find _Event == 0 at this point, but as
5034     // an optional optimization we clear it, just in case can
5035     // multiple unpark() operations drove _Event up to 1.
5036     _Event = 0 ;
5037     OrderAccess::fence() ;
5038     guarantee (_Event >= 0, "invariant") ;
5039 }
5040 
5041 void os::PlatformEvent::unpark() {
5042   guarantee (_ParkHandle != NULL, "Invariant") ;
5043 
5044   // Transitions for _Event:
5045   //    0 :=> 1
5046   //    1 :=> 1
5047   //   -1 :=> either 0 or 1; must signal target thread
5048   //          That is, we can safely transition _Event from -1 to either
5049   //          0 or 1. Forcing 1 is slightly more efficient for back-to-back
5050   //          unpark() calls.
5051   // See also: "Semaphores in Plan 9" by Mullender & Cox
5052   //
5053   // Note: Forcing a transition from "-1" to "1" on an unpark() means
5054   // that it will take two back-to-back park() calls for the owning
5055   // thread to block. This has the benefit of forcing a spurious return
5056   // from the first park() call after an unpark() call which will help
5057   // shake out uses of park() and unpark() without condition variables.
5058 
5059   if (Atomic::xchg(1, &_Event) >= 0) return;
5060 
5061   ::SetEvent(_ParkHandle);
5062 }
5063 
5064 
5065 // JSR166
5066 // -------------------------------------------------------
5067 
5068 /*
5069  * The Windows implementation of Park is very straightforward: Basic
5070  * operations on Win32 Events turn out to have the right semantics to
5071  * use them directly. We opportunistically resuse the event inherited
5072  * from Monitor.
5073  */
5074 
5075 
5076 void Parker::park(bool isAbsolute, jlong time) {
5077   guarantee (_ParkEvent != NULL, "invariant") ;
5078   // First, demultiplex/decode time arguments
5079   if (time < 0) { // don't wait
5080     return;
5081   }
5082   else if (time == 0 && !isAbsolute) {
5083     time = INFINITE;
5084   }
5085   else if  (isAbsolute) {
5086     time -= os::javaTimeMillis(); // convert to relative time
5087     if (time <= 0) // already elapsed
5088       return;
5089   }
5090   else { // relative
5091     time /= 1000000; // Must coarsen from nanos to millis
5092     if (time == 0)   // Wait for the minimal time unit if zero
5093       time = 1;
5094   }
5095 
5096   JavaThread* thread = (JavaThread*)(Thread::current());
5097   assert(thread->is_Java_thread(), "Must be JavaThread");
5098   JavaThread *jt = (JavaThread *)thread;
5099 
5100   // Don't wait if interrupted or already triggered
5101   if (Thread::is_interrupted(thread, false) ||
5102     WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
5103     ResetEvent(_ParkEvent);
5104     return;
5105   }
5106   else {
5107     ThreadBlockInVM tbivm(jt);
5108     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5109     jt->set_suspend_equivalent();
5110 
5111     WaitForSingleObject(_ParkEvent,  time);
5112     ResetEvent(_ParkEvent);
5113 
5114     // If externally suspended while waiting, re-suspend
5115     if (jt->handle_special_suspend_equivalent_condition()) {
5116       jt->java_suspend_self();
5117     }
5118   }
5119 }
5120 
5121 void Parker::unpark() {
5122   guarantee (_ParkEvent != NULL, "invariant") ;
5123   SetEvent(_ParkEvent);
5124 }
5125 
5126 // Run the specified command in a separate process. Return its exit value,
5127 // or -1 on failure (e.g. can't create a new process).
5128 int os::fork_and_exec(char* cmd, bool use_vfork_if_available) {
5129   STARTUPINFO si;
5130   PROCESS_INFORMATION pi;
5131 
5132   memset(&si, 0, sizeof(si));
5133   si.cb = sizeof(si);
5134   memset(&pi, 0, sizeof(pi));
5135   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
5136                             cmd,    // command line
5137                             NULL,   // process security attribute
5138                             NULL,   // thread security attribute
5139                             TRUE,   // inherits system handles
5140                             0,      // no creation flags
5141                             NULL,   // use parent's environment block
5142                             NULL,   // use parent's starting directory
5143                             &si,    // (in) startup information
5144                             &pi);   // (out) process information
5145 
5146   if (rslt) {
5147     // Wait until child process exits.
5148     WaitForSingleObject(pi.hProcess, INFINITE);
5149 
5150     DWORD exit_code;
5151     GetExitCodeProcess(pi.hProcess, &exit_code);
5152 
5153     // Close process and thread handles.
5154     CloseHandle(pi.hProcess);
5155     CloseHandle(pi.hThread);
5156 
5157     return (int)exit_code;
5158   } else {
5159     return -1;
5160   }
5161 }
5162 
5163 //--------------------------------------------------------------------------------------------------
5164 // Non-product code
5165 
5166 static int mallocDebugIntervalCounter = 0;
5167 static int mallocDebugCounter = 0;
5168 bool os::check_heap(bool force) {
5169   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
5170   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
5171     // Note: HeapValidate executes two hardware breakpoints when it finds something
5172     // wrong; at these points, eax contains the address of the offending block (I think).
5173     // To get to the exlicit error message(s) below, just continue twice.
5174     HANDLE heap = GetProcessHeap();
5175     { HeapLock(heap);
5176       PROCESS_HEAP_ENTRY phe;
5177       phe.lpData = NULL;
5178       while (HeapWalk(heap, &phe) != 0) {
5179         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
5180             !HeapValidate(heap, 0, phe.lpData)) {
5181           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
5182           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
5183           fatal("corrupted C heap");
5184         }
5185       }
5186       DWORD err = GetLastError();
5187       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
5188         fatal(err_msg("heap walk aborted with error %d", err));
5189       }
5190       HeapUnlock(heap);
5191     }
5192     mallocDebugIntervalCounter = 0;
5193   }
5194   return true;
5195 }
5196 
5197 
5198 bool os::find(address addr, outputStream* st) {
5199   // Nothing yet
5200   return false;
5201 }
5202 
5203 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5204   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5205 
5206   if ( exception_code == EXCEPTION_ACCESS_VIOLATION ) {
5207     JavaThread* thread = (JavaThread*)ThreadLocalStorage::get_thread_slow();
5208     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5209     address addr = (address) exceptionRecord->ExceptionInformation[1];
5210 
5211     if (os::is_memory_serialize_page(thread, addr))
5212       return EXCEPTION_CONTINUE_EXECUTION;
5213   }
5214 
5215   return EXCEPTION_CONTINUE_SEARCH;
5216 }
5217 
5218 // We don't build a headless jre for Windows
5219 bool os::is_headless_jre() { return false; }
5220 
5221 static jint initSock() {
5222   WSADATA wsadata;
5223 
5224   if (!os::WinSock2Dll::WinSock2Available()) {
5225     jio_fprintf(stderr, "Could not load Winsock (error: %d)\n",
5226       ::GetLastError());
5227     return JNI_ERR;
5228   }
5229 
5230   if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5231     jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5232       ::GetLastError());
5233     return JNI_ERR;
5234   }
5235   return JNI_OK;
5236 }
5237 
5238 struct hostent* os::get_host_by_name(char* name) {
5239   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
5240 }
5241 
5242 int os::socket_close(int fd) {
5243   return ::closesocket(fd);
5244 }
5245 
5246 int os::socket_available(int fd, jint *pbytes) {
5247   int ret = ::ioctlsocket(fd, FIONREAD, (u_long*)pbytes);
5248   return (ret < 0) ? 0 : 1;
5249 }
5250 
5251 int os::socket(int domain, int type, int protocol) {
5252   return ::socket(domain, type, protocol);
5253 }
5254 
5255 int os::listen(int fd, int count) {
5256   return ::listen(fd, count);
5257 }
5258 
5259 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5260   return ::connect(fd, him, len);
5261 }
5262 
5263 int os::accept(int fd, struct sockaddr* him, socklen_t* len) {
5264   return ::accept(fd, him, len);
5265 }
5266 
5267 int os::sendto(int fd, char* buf, size_t len, uint flags,
5268                struct sockaddr* to, socklen_t tolen) {
5269 
5270   return ::sendto(fd, buf, (int)len, flags, to, tolen);
5271 }
5272 
5273 int os::recvfrom(int fd, char *buf, size_t nBytes, uint flags,
5274                  sockaddr* from, socklen_t* fromlen) {
5275 
5276   return ::recvfrom(fd, buf, (int)nBytes, flags, from, fromlen);
5277 }
5278 
5279 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5280   return ::recv(fd, buf, (int)nBytes, flags);
5281 }
5282 
5283 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5284   return ::send(fd, buf, (int)nBytes, flags);
5285 }
5286 
5287 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5288   return ::send(fd, buf, (int)nBytes, flags);
5289 }
5290 
5291 int os::timeout(int fd, long timeout) {
5292   fd_set tbl;
5293   struct timeval t;
5294 
5295   t.tv_sec  = timeout / 1000;
5296   t.tv_usec = (timeout % 1000) * 1000;
5297 
5298   tbl.fd_count    = 1;
5299   tbl.fd_array[0] = fd;
5300 
5301   return ::select(1, &tbl, 0, 0, &t);
5302 }
5303 
5304 int os::get_host_name(char* name, int namelen) {
5305   return ::gethostname(name, namelen);
5306 }
5307 
5308 int os::socket_shutdown(int fd, int howto) {
5309   return ::shutdown(fd, howto);
5310 }
5311 
5312 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
5313   return ::bind(fd, him, len);
5314 }
5315 
5316 int os::get_sock_name(int fd, struct sockaddr* him, socklen_t* len) {
5317   return ::getsockname(fd, him, len);
5318 }
5319 
5320 int os::get_sock_opt(int fd, int level, int optname,
5321                      char* optval, socklen_t* optlen) {
5322   return ::getsockopt(fd, level, optname, optval, optlen);
5323 }
5324 
5325 int os::set_sock_opt(int fd, int level, int optname,
5326                      const char* optval, socklen_t optlen) {
5327   return ::setsockopt(fd, level, optname, optval, optlen);
5328 }
5329 
5330 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5331 #if defined(IA32)
5332 #  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5333 #elif defined (AMD64)
5334 #  define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5335 #endif
5336 
5337 // returns true if thread could be suspended,
5338 // false otherwise
5339 static bool do_suspend(HANDLE* h) {
5340   if (h != NULL) {
5341     if (SuspendThread(*h) != ~0) {
5342       return true;
5343     }
5344   }
5345   return false;
5346 }
5347 
5348 // resume the thread
5349 // calling resume on an active thread is a no-op
5350 static void do_resume(HANDLE* h) {
5351   if (h != NULL) {
5352     ResumeThread(*h);
5353   }
5354 }
5355 
5356 // retrieve a suspend/resume context capable handle
5357 // from the tid. Caller validates handle return value.
5358 void get_thread_handle_for_extended_context(HANDLE* h, OSThread::thread_id_t tid) {
5359   if (h != NULL) {
5360     *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5361   }
5362 }
5363 
5364 //
5365 // Thread sampling implementation
5366 //
5367 void os::SuspendedThreadTask::internal_do_task() {
5368   CONTEXT    ctxt;
5369   HANDLE     h = NULL;
5370 
5371   // get context capable handle for thread
5372   get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5373 
5374   // sanity
5375   if (h == NULL || h == INVALID_HANDLE_VALUE) {
5376     return;
5377   }
5378 
5379   // suspend the thread
5380   if (do_suspend(&h)) {
5381     ctxt.ContextFlags = sampling_context_flags;
5382     // get thread context
5383     GetThreadContext(h, &ctxt);
5384     SuspendedThreadTaskContext context(_thread, &ctxt);
5385     // pass context to Thread Sampling impl
5386     do_task(context);
5387     // resume thread
5388     do_resume(&h);
5389   }
5390 
5391   // close handle
5392   CloseHandle(h);
5393 }
5394 
5395 
5396 // Kernel32 API
5397 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
5398 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn) (HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
5399 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn) (PULONG);
5400 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn) (UCHAR, PULONGLONG);
5401 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
5402 
5403 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
5404 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
5405 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
5406 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
5407 RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL;
5408 
5409 
5410 BOOL                        os::Kernel32Dll::initialized = FALSE;
5411 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
5412   assert(initialized && _GetLargePageMinimum != NULL,
5413     "GetLargePageMinimumAvailable() not yet called");
5414   return _GetLargePageMinimum();
5415 }
5416 
5417 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
5418   if (!initialized) {
5419     initialize();
5420   }
5421   return _GetLargePageMinimum != NULL;
5422 }
5423 
5424 BOOL os::Kernel32Dll::NumaCallsAvailable() {
5425   if (!initialized) {
5426     initialize();
5427   }
5428   return _VirtualAllocExNuma != NULL;
5429 }
5430 
5431 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr, SIZE_T bytes, DWORD flags, DWORD prot, DWORD node) {
5432   assert(initialized && _VirtualAllocExNuma != NULL,
5433     "NUMACallsAvailable() not yet called");
5434 
5435   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
5436 }
5437 
5438 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
5439   assert(initialized && _GetNumaHighestNodeNumber != NULL,
5440     "NUMACallsAvailable() not yet called");
5441 
5442   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
5443 }
5444 
5445 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node, PULONGLONG proc_mask) {
5446   assert(initialized && _GetNumaNodeProcessorMask != NULL,
5447     "NUMACallsAvailable() not yet called");
5448 
5449   return _GetNumaNodeProcessorMask(node, proc_mask);
5450 }
5451 
5452 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
5453   ULONG FrameToCapture, PVOID* BackTrace, PULONG BackTraceHash) {
5454     if (!initialized) {
5455       initialize();
5456     }
5457 
5458     if (_RtlCaptureStackBackTrace != NULL) {
5459       return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture,
5460         BackTrace, BackTraceHash);
5461     } else {
5462       return 0;
5463     }
5464 }
5465 
5466 void os::Kernel32Dll::initializeCommon() {
5467   if (!initialized) {
5468     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5469     assert(handle != NULL, "Just check");
5470     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
5471     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
5472     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
5473     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
5474     _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace");
5475     initialized = TRUE;
5476   }
5477 }
5478 
5479 
5480 
5481 #ifndef JDK6_OR_EARLIER
5482 
5483 void os::Kernel32Dll::initialize() {
5484   initializeCommon();
5485 }
5486 
5487 
5488 // Kernel32 API
5489 inline BOOL os::Kernel32Dll::SwitchToThread() {
5490   return ::SwitchToThread();
5491 }
5492 
5493 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5494   return true;
5495 }
5496 
5497   // Help tools
5498 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5499   return true;
5500 }
5501 
5502 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5503   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5504 }
5505 
5506 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5507   return ::Module32First(hSnapshot, lpme);
5508 }
5509 
5510 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5511   return ::Module32Next(hSnapshot, lpme);
5512 }
5513 
5514 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5515   ::GetNativeSystemInfo(lpSystemInfo);
5516 }
5517 
5518 // PSAPI API
5519 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5520   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5521 }
5522 
5523 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5524   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5525 }
5526 
5527 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5528   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5529 }
5530 
5531 inline BOOL os::PSApiDll::PSApiAvailable() {
5532   return true;
5533 }
5534 
5535 
5536 // WinSock2 API
5537 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5538   return ::WSAStartup(wVersionRequested, lpWSAData);
5539 }
5540 
5541 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5542   return ::gethostbyname(name);
5543 }
5544 
5545 inline BOOL os::WinSock2Dll::WinSock2Available() {
5546   return true;
5547 }
5548 
5549 // Advapi API
5550 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5551    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5552    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5553      return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5554        BufferLength, PreviousState, ReturnLength);
5555 }
5556 
5557 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5558   PHANDLE TokenHandle) {
5559     return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5560 }
5561 
5562 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5563   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5564 }
5565 
5566 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5567   return true;
5568 }
5569 
5570 void* os::get_default_process_handle() {
5571   return (void*)GetModuleHandle(NULL);
5572 }
5573 
5574 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
5575 // which is used to find statically linked in agents.
5576 // Additionally for windows, takes into account __stdcall names.
5577 // Parameters:
5578 //            sym_name: Symbol in library we are looking for
5579 //            lib_name: Name of library to look in, NULL for shared libs.
5580 //            is_absolute_path == true if lib_name is absolute path to agent
5581 //                                     such as "C:/a/b/L.dll"
5582 //            == false if only the base name of the library is passed in
5583 //               such as "L"
5584 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
5585                                     bool is_absolute_path) {
5586   char *agent_entry_name;
5587   size_t len;
5588   size_t name_len;
5589   size_t prefix_len = strlen(JNI_LIB_PREFIX);
5590   size_t suffix_len = strlen(JNI_LIB_SUFFIX);
5591   const char *start;
5592 
5593   if (lib_name != NULL) {
5594     len = name_len = strlen(lib_name);
5595     if (is_absolute_path) {
5596       // Need to strip path, prefix and suffix
5597       if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
5598         lib_name = ++start;
5599       } else {
5600         // Need to check for drive prefix
5601         if ((start = strchr(lib_name, ':')) != NULL) {
5602           lib_name = ++start;
5603         }
5604       }
5605       if (len <= (prefix_len + suffix_len)) {
5606         return NULL;
5607       }
5608       lib_name += prefix_len;
5609       name_len = strlen(lib_name) - suffix_len;
5610     }
5611   }
5612   len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
5613   agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
5614   if (agent_entry_name == NULL) {
5615     return NULL;
5616   }
5617   if (lib_name != NULL) {
5618     const char *p = strrchr(sym_name, '@');
5619     if (p != NULL && p != sym_name) {
5620       // sym_name == _Agent_OnLoad@XX
5621       strncpy(agent_entry_name, sym_name, (p - sym_name));
5622       agent_entry_name[(p-sym_name)] = '\0';
5623       // agent_entry_name == _Agent_OnLoad
5624       strcat(agent_entry_name, "_");
5625       strncat(agent_entry_name, lib_name, name_len);
5626       strcat(agent_entry_name, p);
5627       // agent_entry_name == _Agent_OnLoad_lib_name@XX
5628     } else {
5629       strcpy(agent_entry_name, sym_name);
5630       strcat(agent_entry_name, "_");
5631       strncat(agent_entry_name, lib_name, name_len);
5632     }
5633   } else {
5634     strcpy(agent_entry_name, sym_name);
5635   }
5636   return agent_entry_name;
5637 }
5638 
5639 #else
5640 // Kernel32 API
5641 typedef BOOL (WINAPI* SwitchToThread_Fn)(void);
5642 typedef HANDLE (WINAPI* CreateToolhelp32Snapshot_Fn)(DWORD,DWORD);
5643 typedef BOOL (WINAPI* Module32First_Fn)(HANDLE,LPMODULEENTRY32);
5644 typedef BOOL (WINAPI* Module32Next_Fn)(HANDLE,LPMODULEENTRY32);
5645 typedef void (WINAPI* GetNativeSystemInfo_Fn)(LPSYSTEM_INFO);
5646 
5647 SwitchToThread_Fn           os::Kernel32Dll::_SwitchToThread = NULL;
5648 CreateToolhelp32Snapshot_Fn os::Kernel32Dll::_CreateToolhelp32Snapshot = NULL;
5649 Module32First_Fn            os::Kernel32Dll::_Module32First = NULL;
5650 Module32Next_Fn             os::Kernel32Dll::_Module32Next = NULL;
5651 GetNativeSystemInfo_Fn      os::Kernel32Dll::_GetNativeSystemInfo = NULL;
5652 
5653 void os::Kernel32Dll::initialize() {
5654   if (!initialized) {
5655     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5656     assert(handle != NULL, "Just check");
5657 
5658     _SwitchToThread = (SwitchToThread_Fn)::GetProcAddress(handle, "SwitchToThread");
5659     _CreateToolhelp32Snapshot = (CreateToolhelp32Snapshot_Fn)
5660       ::GetProcAddress(handle, "CreateToolhelp32Snapshot");
5661     _Module32First = (Module32First_Fn)::GetProcAddress(handle, "Module32First");
5662     _Module32Next = (Module32Next_Fn)::GetProcAddress(handle, "Module32Next");
5663     _GetNativeSystemInfo = (GetNativeSystemInfo_Fn)::GetProcAddress(handle, "GetNativeSystemInfo");
5664     initializeCommon();  // resolve the functions that always need resolving
5665 
5666     initialized = TRUE;
5667   }
5668 }
5669 
5670 BOOL os::Kernel32Dll::SwitchToThread() {
5671   assert(initialized && _SwitchToThread != NULL,
5672     "SwitchToThreadAvailable() not yet called");
5673   return _SwitchToThread();
5674 }
5675 
5676 
5677 BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5678   if (!initialized) {
5679     initialize();
5680   }
5681   return _SwitchToThread != NULL;
5682 }
5683 
5684 // Help tools
5685 BOOL os::Kernel32Dll::HelpToolsAvailable() {
5686   if (!initialized) {
5687     initialize();
5688   }
5689   return _CreateToolhelp32Snapshot != NULL &&
5690          _Module32First != NULL &&
5691          _Module32Next != NULL;
5692 }
5693 
5694 HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,DWORD th32ProcessId) {
5695   assert(initialized && _CreateToolhelp32Snapshot != NULL,
5696     "HelpToolsAvailable() not yet called");
5697 
5698   return _CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5699 }
5700 
5701 BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5702   assert(initialized && _Module32First != NULL,
5703     "HelpToolsAvailable() not yet called");
5704 
5705   return _Module32First(hSnapshot, lpme);
5706 }
5707 
5708 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,LPMODULEENTRY32 lpme) {
5709   assert(initialized && _Module32Next != NULL,
5710     "HelpToolsAvailable() not yet called");
5711 
5712   return _Module32Next(hSnapshot, lpme);
5713 }
5714 
5715 
5716 BOOL os::Kernel32Dll::GetNativeSystemInfoAvailable() {
5717   if (!initialized) {
5718     initialize();
5719   }
5720   return _GetNativeSystemInfo != NULL;
5721 }
5722 
5723 void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5724   assert(initialized && _GetNativeSystemInfo != NULL,
5725     "GetNativeSystemInfoAvailable() not yet called");
5726 
5727   _GetNativeSystemInfo(lpSystemInfo);
5728 }
5729 
5730 // PSAPI API
5731 
5732 
5733 typedef BOOL (WINAPI *EnumProcessModules_Fn)(HANDLE, HMODULE *, DWORD, LPDWORD);
5734 typedef BOOL (WINAPI *GetModuleFileNameEx_Fn)(HANDLE, HMODULE, LPTSTR, DWORD);;
5735 typedef BOOL (WINAPI *GetModuleInformation_Fn)(HANDLE, HMODULE, LPMODULEINFO, DWORD);
5736 
5737 EnumProcessModules_Fn   os::PSApiDll::_EnumProcessModules = NULL;
5738 GetModuleFileNameEx_Fn  os::PSApiDll::_GetModuleFileNameEx = NULL;
5739 GetModuleInformation_Fn os::PSApiDll::_GetModuleInformation = NULL;
5740 BOOL                    os::PSApiDll::initialized = FALSE;
5741 
5742 void os::PSApiDll::initialize() {
5743   if (!initialized) {
5744     HMODULE handle = os::win32::load_Windows_dll("PSAPI.DLL", NULL, 0);
5745     if (handle != NULL) {
5746       _EnumProcessModules = (EnumProcessModules_Fn)::GetProcAddress(handle,
5747         "EnumProcessModules");
5748       _GetModuleFileNameEx = (GetModuleFileNameEx_Fn)::GetProcAddress(handle,
5749         "GetModuleFileNameExA");
5750       _GetModuleInformation = (GetModuleInformation_Fn)::GetProcAddress(handle,
5751         "GetModuleInformation");
5752     }
5753     initialized = TRUE;
5754   }
5755 }
5756 
5757 
5758 
5759 BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess, HMODULE *lpModule, DWORD cb, LPDWORD lpcbNeeded) {
5760   assert(initialized && _EnumProcessModules != NULL,
5761     "PSApiAvailable() not yet called");
5762   return _EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5763 }
5764 
5765 DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess, HMODULE hModule, LPTSTR lpFilename, DWORD nSize) {
5766   assert(initialized && _GetModuleFileNameEx != NULL,
5767     "PSApiAvailable() not yet called");
5768   return _GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5769 }
5770 
5771 BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb) {
5772   assert(initialized && _GetModuleInformation != NULL,
5773     "PSApiAvailable() not yet called");
5774   return _GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5775 }
5776 
5777 BOOL os::PSApiDll::PSApiAvailable() {
5778   if (!initialized) {
5779     initialize();
5780   }
5781   return _EnumProcessModules != NULL &&
5782     _GetModuleFileNameEx != NULL &&
5783     _GetModuleInformation != NULL;
5784 }
5785 
5786 
5787 // WinSock2 API
5788 typedef int (PASCAL FAR* WSAStartup_Fn)(WORD, LPWSADATA);
5789 typedef struct hostent *(PASCAL FAR *gethostbyname_Fn)(...);
5790 
5791 WSAStartup_Fn    os::WinSock2Dll::_WSAStartup = NULL;
5792 gethostbyname_Fn os::WinSock2Dll::_gethostbyname = NULL;
5793 BOOL             os::WinSock2Dll::initialized = FALSE;
5794 
5795 void os::WinSock2Dll::initialize() {
5796   if (!initialized) {
5797     HMODULE handle = os::win32::load_Windows_dll("ws2_32.dll", NULL, 0);
5798     if (handle != NULL) {
5799       _WSAStartup = (WSAStartup_Fn)::GetProcAddress(handle, "WSAStartup");
5800       _gethostbyname = (gethostbyname_Fn)::GetProcAddress(handle, "gethostbyname");
5801     }
5802     initialized = TRUE;
5803   }
5804 }
5805 
5806 
5807 BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData) {
5808   assert(initialized && _WSAStartup != NULL,
5809     "WinSock2Available() not yet called");
5810   return _WSAStartup(wVersionRequested, lpWSAData);
5811 }
5812 
5813 struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5814   assert(initialized && _gethostbyname != NULL,
5815     "WinSock2Available() not yet called");
5816   return _gethostbyname(name);
5817 }
5818 
5819 BOOL os::WinSock2Dll::WinSock2Available() {
5820   if (!initialized) {
5821     initialize();
5822   }
5823   return _WSAStartup != NULL &&
5824     _gethostbyname != NULL;
5825 }
5826 
5827 typedef BOOL (WINAPI *AdjustTokenPrivileges_Fn)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
5828 typedef BOOL (WINAPI *OpenProcessToken_Fn)(HANDLE, DWORD, PHANDLE);
5829 typedef BOOL (WINAPI *LookupPrivilegeValue_Fn)(LPCTSTR, LPCTSTR, PLUID);
5830 
5831 AdjustTokenPrivileges_Fn os::Advapi32Dll::_AdjustTokenPrivileges = NULL;
5832 OpenProcessToken_Fn      os::Advapi32Dll::_OpenProcessToken = NULL;
5833 LookupPrivilegeValue_Fn  os::Advapi32Dll::_LookupPrivilegeValue = NULL;
5834 BOOL                     os::Advapi32Dll::initialized = FALSE;
5835 
5836 void os::Advapi32Dll::initialize() {
5837   if (!initialized) {
5838     HMODULE handle = os::win32::load_Windows_dll("advapi32.dll", NULL, 0);
5839     if (handle != NULL) {
5840       _AdjustTokenPrivileges = (AdjustTokenPrivileges_Fn)::GetProcAddress(handle,
5841         "AdjustTokenPrivileges");
5842       _OpenProcessToken = (OpenProcessToken_Fn)::GetProcAddress(handle,
5843         "OpenProcessToken");
5844       _LookupPrivilegeValue = (LookupPrivilegeValue_Fn)::GetProcAddress(handle,
5845         "LookupPrivilegeValueA");
5846     }
5847     initialized = TRUE;
5848   }
5849 }
5850 
5851 BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5852    BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength,
5853    PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength) {
5854    assert(initialized && _AdjustTokenPrivileges != NULL,
5855      "AdvapiAvailable() not yet called");
5856    return _AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5857        BufferLength, PreviousState, ReturnLength);
5858 }
5859 
5860 BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess,
5861   PHANDLE TokenHandle) {
5862    assert(initialized && _OpenProcessToken != NULL,
5863      "AdvapiAvailable() not yet called");
5864     return _OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5865 }
5866 
5867 BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid) {
5868    assert(initialized && _LookupPrivilegeValue != NULL,
5869      "AdvapiAvailable() not yet called");
5870   return _LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5871 }
5872 
5873 BOOL os::Advapi32Dll::AdvapiAvailable() {
5874   if (!initialized) {
5875     initialize();
5876   }
5877   return _AdjustTokenPrivileges != NULL &&
5878     _OpenProcessToken != NULL &&
5879     _LookupPrivilegeValue != NULL;
5880 }
5881 
5882 #endif
5883 
5884 #ifndef PRODUCT
5885 
5886 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5887 // contiguous memory block at a particular address.
5888 // The test first tries to find a good approximate address to allocate at by using the same
5889 // method to allocate some memory at any address. The test then tries to allocate memory in
5890 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5891 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5892 // the previously allocated memory is available for allocation. The only actual failure
5893 // that is reported is when the test tries to allocate at a particular location but gets a
5894 // different valid one. A NULL return value at this point is not considered an error but may
5895 // be legitimate.
5896 // If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages.
5897 void TestReserveMemorySpecial_test() {
5898   if (!UseLargePages) {
5899     if (VerboseInternalVMTests) {
5900       gclog_or_tty->print("Skipping test because large pages are disabled");
5901     }
5902     return;
5903   }
5904   // save current value of globals
5905   bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5906   bool old_use_numa_interleaving = UseNUMAInterleaving;
5907 
5908   // set globals to make sure we hit the correct code path
5909   UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5910 
5911   // do an allocation at an address selected by the OS to get a good one.
5912   const size_t large_allocation_size = os::large_page_size() * 4;
5913   char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5914   if (result == NULL) {
5915     if (VerboseInternalVMTests) {
5916       gclog_or_tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
5917         large_allocation_size);
5918     }
5919   } else {
5920     os::release_memory_special(result, large_allocation_size);
5921 
5922     // allocate another page within the recently allocated memory area which seems to be a good location. At least
5923     // we managed to get it once.
5924     const size_t expected_allocation_size = os::large_page_size();
5925     char* expected_location = result + os::large_page_size();
5926     char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5927     if (actual_location == NULL) {
5928       if (VerboseInternalVMTests) {
5929         gclog_or_tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
5930           expected_location, large_allocation_size);
5931       }
5932     } else {
5933       // release memory
5934       os::release_memory_special(actual_location, expected_allocation_size);
5935       // only now check, after releasing any memory to avoid any leaks.
5936       assert(actual_location == expected_location,
5937         err_msg("Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
5938           expected_location, expected_allocation_size, actual_location));
5939     }
5940   }
5941 
5942   // restore globals
5943   UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5944   UseNUMAInterleaving = old_use_numa_interleaving;
5945 }
5946 #endif // PRODUCT
5947