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