rev 6314 : imported patch nmtfix

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