rev 6314 : imported patch nmtfix

   1 /*
   2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // Must be at least Windows 2000 or XP to use IsDebuggerPresent
  26 #define _WIN32_WINNT 0x500
  27 
  28 // no precompiled headers
  29 #include "classfile/classLoader.hpp"
  30 #include "classfile/systemDictionary.hpp"
  31 #include "classfile/vmSymbols.hpp"
  32 #include "code/icBuffer.hpp"
  33 #include "code/vtableStubs.hpp"
  34 #include "compiler/compileBroker.hpp"
  35 #include "compiler/disassembler.hpp"
  36 #include "interpreter/interpreter.hpp"
  37 #include "jvm_windows.h"
  38 #include "memory/allocation.inline.hpp"
  39 #include "memory/filemap.hpp"
  40 #include "mutex_windows.inline.hpp"
  41 #include "oops/oop.inline.hpp"
  42 #include "os_share_windows.hpp"
  43 #include "prims/jniFastGetField.hpp"
  44 #include "prims/jvm.h"
  45 #include "prims/jvm_misc.hpp"
  46 #include "runtime/arguments.hpp"
  47 #include "runtime/extendedPC.hpp"
  48 #include "runtime/globals.hpp"
  49 #include "runtime/interfaceSupport.hpp"
  50 #include "runtime/java.hpp"
  51 #include "runtime/javaCalls.hpp"
  52 #include "runtime/mutexLocker.hpp"
  53 #include "runtime/objectMonitor.hpp"
  54 #include "runtime/osThread.hpp"
  55 #include "runtime/perfMemory.hpp"
  56 #include "runtime/sharedRuntime.hpp"
  57 #include "runtime/statSampler.hpp"
  58 #include "runtime/stubRoutines.hpp"
  59 #include "runtime/thread.inline.hpp"
  60 #include "runtime/threadCritical.hpp"
  61 #include "runtime/timer.hpp"
  62 #include "services/attachListener.hpp"
  63 #include "services/memTracker.hpp"
  64 #include "services/runtimeService.hpp"
  65 #include "utilities/decoder.hpp"
  66 #include "utilities/defaultStream.hpp"
  67 #include "utilities/events.hpp"
  68 #include "utilities/growableArray.hpp"
  69 #include "utilities/vmError.hpp"
  70 
  71 #ifdef _DEBUG
  72 #include <crtdbg.h>
  73 #endif
  74 
  75 
  76 #include <windows.h>
  77 #include <sys/types.h>
  78 #include <sys/stat.h>
  79 #include <sys/timeb.h>
  80 #include <objidl.h>
  81 #include <shlobj.h>
  82 
  83 #include <malloc.h>
  84 #include <signal.h>
  85 #include <direct.h>
  86 #include <errno.h>
  87 #include <fcntl.h>
  88 #include <io.h>
  89 #include <process.h>              // For _beginthreadex(), _endthreadex()
  90 #include <imagehlp.h>             // For os::dll_address_to_function_name
  91 /* for enumerating dll libraries */
  92 #include <vdmdbg.h>
  93 
  94 // for timer info max values which include all bits
  95 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
  96 
  97 // For DLL loading/load error detection
  98 // Values of PE COFF
  99 #define IMAGE_FILE_PTR_TO_SIGNATURE 0x3c
 100 #define IMAGE_FILE_SIGNATURE_LENGTH 4
 101 
 102 static HANDLE main_process;
 103 static HANDLE main_thread;
 104 static int    main_thread_id;
 105 
 106 static FILETIME process_creation_time;
 107 static FILETIME process_exit_time;
 108 static FILETIME process_user_time;
 109 static FILETIME process_kernel_time;
 110 
 111 #ifdef _M_IA64
 112 #define __CPU__ ia64
 113 #elif _M_AMD64
 114 #define __CPU__ amd64
 115 #else
 116 #define __CPU__ i486
 117 #endif
 118 
 119 // save DLL module handle, used by GetModuleFileName
 120 
 121 HINSTANCE vm_lib_handle;
 122 
 123 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
 124   switch (reason) {
 125     case DLL_PROCESS_ATTACH:
 126       vm_lib_handle = hinst;
 127       if(ForceTimeHighResolution)
 128         timeBeginPeriod(1L);
 129       break;
 130     case DLL_PROCESS_DETACH:
 131       if(ForceTimeHighResolution)
 132         timeEndPeriod(1L);







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