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