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 precision,
 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 MAXIMUM_THREADS_TO_KEEP (16 * MAXIMUM_WAIT_OBJECTS)
3890 #define EXIT_TIMEOUT 300000 /* 5 minutes */
3891 
3892 static BOOL CALLBACK init_crit_sect_call(PINIT_ONCE, PVOID pcrit_sect, PVOID*) {
3893   InitializeCriticalSection((CRITICAL_SECTION*)pcrit_sect);
3894   return TRUE;
3895 }
3896 
3897 int os::win32::exit_process_or_thread(Ept what, int exit_code) {
3898   // Basic approach:
3899   //  - Each exiting thread registers its intent to exit and then does so.
3900   //  - A thread trying to terminate the process must wait for all
3901   //    threads currently exiting to complete their exit.
3902 
3903   if (os::win32::has_exit_bug()) {
3904     // The array holds handles of the threads that have started exiting by calling
3905     // _endthreadex().
3906     // Should be large enough to avoid blocking the exiting thread due to lack of
3907     // a free slot.
3908     static HANDLE handles[MAXIMUM_THREADS_TO_KEEP];
3909     static int handle_count = 0;
3910 
3911     static INIT_ONCE init_once_crit_sect = INIT_ONCE_STATIC_INIT;
3912     static CRITICAL_SECTION crit_sect;
3913     static volatile jint process_exiting = 0;
3914     jint pr_ex;
3915     int i, j;
3916     DWORD res;
3917     HANDLE hproc, hthr;
3918 
3919     // The first thread that reached this point, initializes the critical section.
3920     if (!InitOnceExecuteOnce(&init_once_crit_sect, init_crit_sect_call, &crit_sect, NULL)) {
3921       warning("crit_sect initialization failed in %s: %d\n", __FILE__, __LINE__);
3922     } else if (OrderAccess::load_acquire(&process_exiting) == 0) {
3923       if (what != EPT_THREAD) {
3924         Atomic::cmpxchg((jint)GetCurrentThreadId(), &process_exiting, 0);
3925       }
3926       EnterCriticalSection(&crit_sect);
3927 
3928       if (what == EPT_THREAD && OrderAccess::load_acquire(&process_exiting) == 0) {
3929         // Remove from the array those handles of the threads that have completed exiting.
3930         for (i = 0, j = 0; i < handle_count; ++i) {
3931           res = WaitForSingleObject(handles[i], 0 /* don't wait */);
3932           if (res == WAIT_TIMEOUT) {
3933             handles[j++] = handles[i];
3934           } else {
3935             if (res == WAIT_FAILED) {
3936               warning("WaitForSingleObject failed (%u) in %s: %d\n",
3937                       GetLastError(), __FILE__, __LINE__);
3938             }
3939             // Don't keep the handle, if we failed waiting for it.
3940             CloseHandle(handles[i]);
3941           }
3942         }
3943 
3944         // If there's no free slot in the array of the kept handles, we'll have to
3945         // wait until at least one thread completes exiting.
3946         if ((handle_count = j) == MAXIMUM_THREADS_TO_KEEP) {
3947           // Raise the priority of the oldest exiting thread to increase its chances
3948           // to complete sooner.
3949           SetThreadPriority(handles[0], THREAD_PRIORITY_ABOVE_NORMAL);
3950           res = WaitForMultipleObjects(MAXIMUM_WAIT_OBJECTS, handles, FALSE, EXIT_TIMEOUT);
3951           if (res >= WAIT_OBJECT_0 && res < (WAIT_OBJECT_0 + MAXIMUM_WAIT_OBJECTS)) {
3952             i = (res - WAIT_OBJECT_0);
3953             handle_count = MAXIMUM_THREADS_TO_KEEP - 1;
3954             for (; i < handle_count; ++i) {
3955               handles[i] = handles[i + 1];
3956             }
3957           } else {
3958             warning("WaitForMultipleObjects %s (%u) in %s: %d\n",
3959                     (res == WAIT_FAILED ? "failed" : "timed out"),
3960                     GetLastError(), __FILE__, __LINE__);
3961             // Don't keep handles, if we failed waiting for them.
3962             for (i = 0; i < MAXIMUM_THREADS_TO_KEEP; ++i) {
3963               CloseHandle(handles[i]);
3964             }
3965             handle_count = 0;
3966           }
3967         }
3968 
3969         // Store a duplicate of the current thread handle in the array of handles.
3970         hproc = GetCurrentProcess();
3971         hthr = GetCurrentThread();
3972         if (!DuplicateHandle(hproc, hthr, hproc, &handles[handle_count],
3973                              0, FALSE, DUPLICATE_SAME_ACCESS)) {
3974           warning("DuplicateHandle failed (%u) in %s: %d\n",
3975                   GetLastError(), __FILE__, __LINE__);
3976         } else {
3977           ++handle_count;
3978         }
3979 
3980         // The current exiting thread has stored its handle in the array, and now
3981         // should leave the critical section before calling _endthreadex().
3982 
3983       } else if (what != EPT_THREAD) {
3984         if (handle_count > 0) {
3985           jlong start_time, finish_time, timeout_left;
3986           // Before ending the process, make sure all the threads that had called
3987           // _endthreadex() completed.
3988 
3989           // Set the priority level of the current thread to the same value as
3990           // the priority level of exiting threads.
3991           // This is to ensure it will be given a fair chance to execute if
3992           // the timeout expires.
3993           hthr = GetCurrentThread();
3994           SetThreadPriority(hthr, THREAD_PRIORITY_ABOVE_NORMAL);
3995           start_time = os::javaTimeNanos();
3996           finish_time = start_time + ((jlong)EXIT_TIMEOUT * 1000000L);
3997           for (i = 0; ; ) {
3998             int portion_count = handle_count - i;
3999             if (portion_count > MAXIMUM_WAIT_OBJECTS) {
4000                 portion_count = MAXIMUM_WAIT_OBJECTS;
4001             }
4002             for (j = 0; j < portion_count; ++j) {
4003               SetThreadPriority(handles[i + j], THREAD_PRIORITY_ABOVE_NORMAL);
4004             }
4005             timeout_left = (finish_time - start_time) / 1000000L;
4006             if (timeout_left < 0) {
4007               timeout_left = 0;
4008             }
4009             res = WaitForMultipleObjects(portion_count, handles + i, TRUE, timeout_left);
4010             if (res == WAIT_FAILED || res == WAIT_TIMEOUT) {
4011               warning("WaitForMultipleObjects %s (%u) in %s: %d\n",
4012                       (res == WAIT_FAILED ? "failed" : "timed out"),
4013                       GetLastError(), __FILE__, __LINE__);
4014               portion_count = handle_count - i;
4015             }
4016             for (j = 0; j < portion_count; ++j) {
4017               CloseHandle(handles[i + j]);
4018             }
4019             if ((i += portion_count) >= handle_count) {
4020               break;
4021             }
4022             start_time = os::javaTimeNanos();
4023           }
4024           handle_count = 0;
4025         }
4026       }
4027 
4028       LeaveCriticalSection(&crit_sect);
4029     }
4030 
4031     if ((pr_ex = OrderAccess::load_acquire(&process_exiting)) != 0) {
4032       jint curr_id = (jint)GetCurrentThreadId();
4033       while (pr_ex != curr_id) {
4034         // Some other thread is about to call exit(), so we
4035         // don't let the current thread proceed to exit() or _endthreadex()
4036         SuspendThread(GetCurrentThread());
4037         // Avoid busy-wait loop, if SuspendThread() failed.
4038         Sleep(EXIT_TIMEOUT);
4039       }
4040     }
4041   }
4042 
4043   // We are here if either
4044   // - there's no 'race at exit' bug on this OS release;
4045   // - initialization of the critical section failed (unlikely);
4046   // - the current thread has stored its handle and left the critical section;
4047   // - the process-exiting thread has raised the flag and left the critical section.
4048   if (what == EPT_THREAD) {
4049     _endthreadex((unsigned)exit_code);
4050   } else if (what == EPT_PROCESS) {
4051     ::exit(exit_code);
4052   } else {
4053     _exit(exit_code);
4054   }
4055 
4056   // Should not reach here
4057   return exit_code;
4058 }
4059 
4060 #undef EXIT_TIMEOUT
4061 
4062 void os::win32::setmode_streams() {
4063   _setmode(_fileno(stdin), _O_BINARY);
4064   _setmode(_fileno(stdout), _O_BINARY);
4065   _setmode(_fileno(stderr), _O_BINARY);
4066 }
4067 
4068 
4069 bool os::is_debugger_attached() {
4070   return IsDebuggerPresent() ? true : false;
4071 }
4072 
4073 
4074 void os::wait_for_keypress_at_exit(void) {
4075   if (PauseAtExit) {
4076     fprintf(stderr, "Press any key to continue...\n");
4077     fgetc(stdin);
4078   }
4079 }
4080 
4081 
4082 bool os::message_box(const char* title, const char* message) {
4083   int result = MessageBox(NULL, message, title,
4084                           MB_YESNO | MB_ICONERROR | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
4085   return result == IDYES;
4086 }
4087 
4088 #ifndef PRODUCT
4089 #ifndef _WIN64
4090 // Helpers to check whether NX protection is enabled
4091 int nx_exception_filter(_EXCEPTION_POINTERS *pex) {
4092   if (pex->ExceptionRecord->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
4093       pex->ExceptionRecord->NumberParameters > 0 &&
4094       pex->ExceptionRecord->ExceptionInformation[0] ==
4095       EXCEPTION_INFO_EXEC_VIOLATION) {
4096     return EXCEPTION_EXECUTE_HANDLER;
4097   }
4098   return EXCEPTION_CONTINUE_SEARCH;
4099 }
4100 
4101 void nx_check_protection() {
4102   // If NX is enabled we'll get an exception calling into code on the stack
4103   char code[] = { (char)0xC3 }; // ret
4104   void *code_ptr = (void *)code;
4105   __try {
4106     __asm call code_ptr
4107   } __except(nx_exception_filter((_EXCEPTION_POINTERS*)_exception_info())) {
4108     tty->print_raw_cr("NX protection detected.");
4109   }
4110 }
4111 #endif // _WIN64
4112 #endif // PRODUCT
4113 
4114 // this is called _before_ the global arguments have been parsed
4115 void os::init(void) {
4116   _initial_pid = _getpid();
4117 
4118   init_random(1234567);
4119 
4120   win32::initialize_system_info();
4121   win32::setmode_streams();
4122   init_page_sizes((size_t) win32::vm_page_size());
4123 
4124   // This may be overridden later when argument processing is done.
4125   FLAG_SET_ERGO(bool, UseLargePagesIndividualAllocation,
4126                 os::win32::is_windows_2003());
4127 
4128   // Initialize main_process and main_thread
4129   main_process = GetCurrentProcess();  // Remember main_process is a pseudo handle
4130   if (!DuplicateHandle(main_process, GetCurrentThread(), main_process,
4131                        &main_thread, THREAD_ALL_ACCESS, false, 0)) {
4132     fatal("DuplicateHandle failed\n");
4133   }
4134   main_thread_id = (int) GetCurrentThreadId();
4135 
4136   // initialize fast thread access - only used for 32-bit
4137   win32::initialize_thread_ptr_offset();
4138 }
4139 
4140 // To install functions for atexit processing
4141 extern "C" {
4142   static void perfMemory_exit_helper() {
4143     perfMemory_exit();
4144   }
4145 }
4146 
4147 static jint initSock();
4148 
4149 // this is called _after_ the global arguments have been parsed
4150 jint os::init_2(void) {
4151   // Allocate a single page and mark it as readable for safepoint polling
4152   address polling_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READONLY);
4153   guarantee(polling_page != NULL, "Reserve Failed for polling page");
4154 
4155   address return_page  = (address)VirtualAlloc(polling_page, os::vm_page_size(), MEM_COMMIT, PAGE_READONLY);
4156   guarantee(return_page != NULL, "Commit Failed for polling page");
4157 
4158   os::set_polling_page(polling_page);
4159 
4160 #ifndef PRODUCT
4161   if (Verbose && PrintMiscellaneous) {
4162     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n",
4163                (intptr_t)polling_page);
4164   }
4165 #endif
4166 
4167   if (!UseMembar) {
4168     address mem_serialize_page = (address)VirtualAlloc(NULL, os::vm_page_size(), MEM_RESERVE, PAGE_READWRITE);
4169     guarantee(mem_serialize_page != NULL, "Reserve Failed for memory serialize page");
4170 
4171     return_page  = (address)VirtualAlloc(mem_serialize_page, os::vm_page_size(), MEM_COMMIT, PAGE_READWRITE);
4172     guarantee(return_page != NULL, "Commit Failed for memory serialize page");
4173 
4174     os::set_memory_serialize_page(mem_serialize_page);
4175 
4176 #ifndef PRODUCT
4177     if (Verbose && PrintMiscellaneous) {
4178       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n",
4179                  (intptr_t)mem_serialize_page);
4180     }
4181 #endif
4182   }
4183 
4184   // Setup Windows Exceptions
4185 
4186   // for debugging float code generation bugs
4187   if (ForceFloatExceptions) {
4188 #ifndef  _WIN64
4189     static long fp_control_word = 0;
4190     __asm { fstcw fp_control_word }
4191     // see Intel PPro Manual, Vol. 2, p 7-16
4192     const long precision = 0x20;
4193     const long underflow = 0x10;
4194     const long overflow  = 0x08;
4195     const long zero_div  = 0x04;
4196     const long denorm    = 0x02;
4197     const long invalid   = 0x01;
4198     fp_control_word |= invalid;
4199     __asm { fldcw fp_control_word }
4200 #endif
4201   }
4202 
4203   // If stack_commit_size is 0, windows will reserve the default size,
4204   // but only commit a small portion of it.
4205   size_t stack_commit_size = round_to(ThreadStackSize*K, os::vm_page_size());
4206   size_t default_reserve_size = os::win32::default_stack_size();
4207   size_t actual_reserve_size = stack_commit_size;
4208   if (stack_commit_size < default_reserve_size) {
4209     // If stack_commit_size == 0, we want this too
4210     actual_reserve_size = default_reserve_size;
4211   }
4212 
4213   // Check minimum allowable stack size for thread creation and to initialize
4214   // the java system classes, including StackOverflowError - depends on page
4215   // size.  Add a page for compiler2 recursion in main thread.
4216   // Add in 2*BytesPerWord times page size to account for VM stack during
4217   // class initialization depending on 32 or 64 bit VM.
4218   size_t min_stack_allowed =
4219             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4220                      2*BytesPerWord COMPILER2_PRESENT(+1)) * os::vm_page_size();
4221   if (actual_reserve_size < min_stack_allowed) {
4222     tty->print_cr("\nThe stack size specified is too small, "
4223                   "Specify at least %dk",
4224                   min_stack_allowed / K);
4225     return JNI_ERR;
4226   }
4227 
4228   JavaThread::set_stack_size_at_create(stack_commit_size);
4229 
4230   // Calculate theoretical max. size of Threads to guard gainst artifical
4231   // out-of-memory situations, where all available address-space has been
4232   // reserved by thread stacks.
4233   assert(actual_reserve_size != 0, "Must have a stack");
4234 
4235   // Calculate the thread limit when we should start doing Virtual Memory
4236   // banging. Currently when the threads will have used all but 200Mb of space.
4237   //
4238   // TODO: consider performing a similar calculation for commit size instead
4239   // as reserve size, since on a 64-bit platform we'll run into that more
4240   // often than running out of virtual memory space.  We can use the
4241   // lower value of the two calculations as the os_thread_limit.
4242   size_t max_address_space = ((size_t)1 << (BitsPerWord - 1)) - (200 * K * K);
4243   win32::_os_thread_limit = (intx)(max_address_space / actual_reserve_size);
4244 
4245   // at exit methods are called in the reverse order of their registration.
4246   // there is no limit to the number of functions registered. atexit does
4247   // not set errno.
4248 
4249   if (PerfAllowAtExitRegistration) {
4250     // only register atexit functions if PerfAllowAtExitRegistration is set.
4251     // atexit functions can be delayed until process exit time, which
4252     // can be problematic for embedded VM situations. Embedded VMs should
4253     // call DestroyJavaVM() to assure that VM resources are released.
4254 
4255     // note: perfMemory_exit_helper atexit function may be removed in
4256     // the future if the appropriate cleanup code can be added to the
4257     // VM_Exit VMOperation's doit method.
4258     if (atexit(perfMemory_exit_helper) != 0) {
4259       warning("os::init_2 atexit(perfMemory_exit_helper) failed");
4260     }
4261   }
4262 
4263 #ifndef _WIN64
4264   // Print something if NX is enabled (win32 on AMD64)
4265   NOT_PRODUCT(if (PrintMiscellaneous && Verbose) nx_check_protection());
4266 #endif
4267 
4268   // initialize thread priority policy
4269   prio_init();
4270 
4271   if (UseNUMA && !ForceNUMA) {
4272     UseNUMA = false; // We don't fully support this yet
4273   }
4274 
4275   if (UseNUMAInterleaving) {
4276     // first check whether this Windows OS supports VirtualAllocExNuma, if not ignore this flag
4277     bool success = numa_interleaving_init();
4278     if (!success) UseNUMAInterleaving = false;
4279   }
4280 
4281   if (initSock() != JNI_OK) {
4282     return JNI_ERR;
4283   }
4284 
4285   return JNI_OK;
4286 }
4287 
4288 // Mark the polling page as unreadable
4289 void os::make_polling_page_unreadable(void) {
4290   DWORD old_status;
4291   if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4292                       PAGE_NOACCESS, &old_status)) {
4293     fatal("Could not disable polling page");
4294   }
4295 }
4296 
4297 // Mark the polling page as readable
4298 void os::make_polling_page_readable(void) {
4299   DWORD old_status;
4300   if (!VirtualProtect((char *)_polling_page, os::vm_page_size(),
4301                       PAGE_READONLY, &old_status)) {
4302     fatal("Could not enable polling page");
4303   }
4304 }
4305 
4306 
4307 int os::stat(const char *path, struct stat *sbuf) {
4308   char pathbuf[MAX_PATH];
4309   if (strlen(path) > MAX_PATH - 1) {
4310     errno = ENAMETOOLONG;
4311     return -1;
4312   }
4313   os::native_path(strcpy(pathbuf, path));
4314   int ret = ::stat(pathbuf, sbuf);
4315   if (sbuf != NULL && UseUTCFileTimestamp) {
4316     // Fix for 6539723.  st_mtime returned from stat() is dependent on
4317     // the system timezone and so can return different values for the
4318     // same file if/when daylight savings time changes.  This adjustment
4319     // makes sure the same timestamp is returned regardless of the TZ.
4320     //
4321     // See:
4322     // http://msdn.microsoft.com/library/
4323     //   default.asp?url=/library/en-us/sysinfo/base/
4324     //   time_zone_information_str.asp
4325     // and
4326     // http://msdn.microsoft.com/library/default.asp?url=
4327     //   /library/en-us/sysinfo/base/settimezoneinformation.asp
4328     //
4329     // NOTE: there is a insidious bug here:  If the timezone is changed
4330     // after the call to stat() but before 'GetTimeZoneInformation()', then
4331     // the adjustment we do here will be wrong and we'll return the wrong
4332     // value (which will likely end up creating an invalid class data
4333     // archive).  Absent a better API for this, or some time zone locking
4334     // mechanism, we'll have to live with this risk.
4335     TIME_ZONE_INFORMATION tz;
4336     DWORD tzid = GetTimeZoneInformation(&tz);
4337     int daylightBias =
4338       (tzid == TIME_ZONE_ID_DAYLIGHT) ?  tz.DaylightBias : tz.StandardBias;
4339     sbuf->st_mtime += (tz.Bias + daylightBias) * 60;
4340   }
4341   return ret;
4342 }
4343 
4344 
4345 #define FT2INT64(ft) \
4346   ((jlong)((jlong)(ft).dwHighDateTime << 32 | (julong)(ft).dwLowDateTime))
4347 
4348 
4349 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4350 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
4351 // of a thread.
4352 //
4353 // current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4354 // the fast estimate available on the platform.
4355 
4356 // current_thread_cpu_time() is not optimized for Windows yet
4357 jlong os::current_thread_cpu_time() {
4358   // return user + sys since the cost is the same
4359   return os::thread_cpu_time(Thread::current(), true /* user+sys */);
4360 }
4361 
4362 jlong os::thread_cpu_time(Thread* thread) {
4363   // consistent with what current_thread_cpu_time() returns.
4364   return os::thread_cpu_time(thread, true /* user+sys */);
4365 }
4366 
4367 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4368   return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4369 }
4370 
4371 jlong os::thread_cpu_time(Thread* thread, bool user_sys_cpu_time) {
4372   // This code is copy from clasic VM -> hpi::sysThreadCPUTime
4373   // If this function changes, os::is_thread_cpu_time_supported() should too
4374   if (os::win32::is_nt()) {
4375     FILETIME CreationTime;
4376     FILETIME ExitTime;
4377     FILETIME KernelTime;
4378     FILETIME UserTime;
4379 
4380     if (GetThreadTimes(thread->osthread()->thread_handle(), &CreationTime,
4381                        &ExitTime, &KernelTime, &UserTime) == 0) {
4382       return -1;
4383     } else if (user_sys_cpu_time) {
4384       return (FT2INT64(UserTime) + FT2INT64(KernelTime)) * 100;
4385     } else {
4386       return FT2INT64(UserTime) * 100;
4387     }
4388   } else {
4389     return (jlong) timeGetTime() * 1000000;
4390   }
4391 }
4392 
4393 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4394   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4395   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4396   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4397   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4398 }
4399 
4400 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4401   info_ptr->max_value = ALL_64_BITS;        // the max value -- all 64 bits
4402   info_ptr->may_skip_backward = false;      // GetThreadTimes returns absolute time
4403   info_ptr->may_skip_forward = false;       // GetThreadTimes returns absolute time
4404   info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;   // user+system time is returned
4405 }
4406 
4407 bool os::is_thread_cpu_time_supported() {
4408   // see os::thread_cpu_time
4409   if (os::win32::is_nt()) {
4410     FILETIME CreationTime;
4411     FILETIME ExitTime;
4412     FILETIME KernelTime;
4413     FILETIME UserTime;
4414 
4415     if (GetThreadTimes(GetCurrentThread(), &CreationTime, &ExitTime,
4416                        &KernelTime, &UserTime) == 0) {
4417       return false;
4418     } else {
4419       return true;
4420     }
4421   } else {
4422     return false;
4423   }
4424 }
4425 
4426 // Windows does't provide a loadavg primitive so this is stubbed out for now.
4427 // It does have primitives (PDH API) to get CPU usage and run queue length.
4428 // "\\Processor(_Total)\\% Processor Time", "\\System\\Processor Queue Length"
4429 // If we wanted to implement loadavg on Windows, we have a few options:
4430 //
4431 // a) Query CPU usage and run queue length and "fake" an answer by
4432 //    returning the CPU usage if it's under 100%, and the run queue
4433 //    length otherwise.  It turns out that querying is pretty slow
4434 //    on Windows, on the order of 200 microseconds on a fast machine.
4435 //    Note that on the Windows the CPU usage value is the % usage
4436 //    since the last time the API was called (and the first call
4437 //    returns 100%), so we'd have to deal with that as well.
4438 //
4439 // b) Sample the "fake" answer using a sampling thread and store
4440 //    the answer in a global variable.  The call to loadavg would
4441 //    just return the value of the global, avoiding the slow query.
4442 //
4443 // c) Sample a better answer using exponential decay to smooth the
4444 //    value.  This is basically the algorithm used by UNIX kernels.
4445 //
4446 // Note that sampling thread starvation could affect both (b) and (c).
4447 int os::loadavg(double loadavg[], int nelem) {
4448   return -1;
4449 }
4450 
4451 
4452 // DontYieldALot=false by default: dutifully perform all yields as requested by JVM_Yield()
4453 bool os::dont_yield() {
4454   return DontYieldALot;
4455 }
4456 
4457 // This method is a slightly reworked copy of JDK's sysOpen
4458 // from src/windows/hpi/src/sys_api_md.c
4459 
4460 int os::open(const char *path, int oflag, int mode) {
4461   char pathbuf[MAX_PATH];
4462 
4463   if (strlen(path) > MAX_PATH - 1) {
4464     errno = ENAMETOOLONG;
4465     return -1;
4466   }
4467   os::native_path(strcpy(pathbuf, path));
4468   return ::open(pathbuf, oflag | O_BINARY | O_NOINHERIT, mode);
4469 }
4470 
4471 FILE* os::open(int fd, const char* mode) {
4472   return ::_fdopen(fd, mode);
4473 }
4474 
4475 // Is a (classpath) directory empty?
4476 bool os::dir_is_empty(const char* path) {
4477   WIN32_FIND_DATA fd;
4478   HANDLE f = FindFirstFile(path, &fd);
4479   if (f == INVALID_HANDLE_VALUE) {
4480     return true;
4481   }
4482   FindClose(f);
4483   return false;
4484 }
4485 
4486 // create binary file, rewriting existing file if required
4487 int os::create_binary_file(const char* path, bool rewrite_existing) {
4488   int oflags = _O_CREAT | _O_WRONLY | _O_BINARY;
4489   if (!rewrite_existing) {
4490     oflags |= _O_EXCL;
4491   }
4492   return ::open(path, oflags, _S_IREAD | _S_IWRITE);
4493 }
4494 
4495 // return current position of file pointer
4496 jlong os::current_file_offset(int fd) {
4497   return (jlong)::_lseeki64(fd, (__int64)0L, SEEK_CUR);
4498 }
4499 
4500 // move file pointer to the specified offset
4501 jlong os::seek_to_file_offset(int fd, jlong offset) {
4502   return (jlong)::_lseeki64(fd, (__int64)offset, SEEK_SET);
4503 }
4504 
4505 
4506 jlong os::lseek(int fd, jlong offset, int whence) {
4507   return (jlong) ::_lseeki64(fd, offset, whence);
4508 }
4509 
4510 size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
4511   OVERLAPPED ov;
4512   DWORD nread;
4513   BOOL result;
4514 
4515   ZeroMemory(&ov, sizeof(ov));
4516   ov.Offset = (DWORD)offset;
4517   ov.OffsetHigh = (DWORD)(offset >> 32);
4518 
4519   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4520 
4521   result = ReadFile(h, (LPVOID)buf, nBytes, &nread, &ov);
4522 
4523   return result ? nread : 0;
4524 }
4525 
4526 
4527 // This method is a slightly reworked copy of JDK's sysNativePath
4528 // from src/windows/hpi/src/path_md.c
4529 
4530 // Convert a pathname to native format.  On win32, this involves forcing all
4531 // separators to be '\\' rather than '/' (both are legal inputs, but Win95
4532 // sometimes rejects '/') and removing redundant separators.  The input path is
4533 // assumed to have been converted into the character encoding used by the local
4534 // system.  Because this might be a double-byte encoding, care is taken to
4535 // treat double-byte lead characters correctly.
4536 //
4537 // This procedure modifies the given path in place, as the result is never
4538 // longer than the original.  There is no error return; this operation always
4539 // succeeds.
4540 char * os::native_path(char *path) {
4541   char *src = path, *dst = path, *end = path;
4542   char *colon = NULL;  // If a drive specifier is found, this will
4543                        // point to the colon following the drive letter
4544 
4545   // Assumption: '/', '\\', ':', and drive letters are never lead bytes
4546   assert(((!::IsDBCSLeadByte('/')) && (!::IsDBCSLeadByte('\\'))
4547           && (!::IsDBCSLeadByte(':'))), "Illegal lead byte");
4548 
4549   // Check for leading separators
4550 #define isfilesep(c) ((c) == '/' || (c) == '\\')
4551   while (isfilesep(*src)) {
4552     src++;
4553   }
4554 
4555   if (::isalpha(*src) && !::IsDBCSLeadByte(*src) && src[1] == ':') {
4556     // Remove leading separators if followed by drive specifier.  This
4557     // hack is necessary to support file URLs containing drive
4558     // specifiers (e.g., "file://c:/path").  As a side effect,
4559     // "/c:/path" can be used as an alternative to "c:/path".
4560     *dst++ = *src++;
4561     colon = dst;
4562     *dst++ = ':';
4563     src++;
4564   } else {
4565     src = path;
4566     if (isfilesep(src[0]) && isfilesep(src[1])) {
4567       // UNC pathname: Retain first separator; leave src pointed at
4568       // second separator so that further separators will be collapsed
4569       // into the second separator.  The result will be a pathname
4570       // beginning with "\\\\" followed (most likely) by a host name.
4571       src = dst = path + 1;
4572       path[0] = '\\';     // Force first separator to '\\'
4573     }
4574   }
4575 
4576   end = dst;
4577 
4578   // Remove redundant separators from remainder of path, forcing all
4579   // separators to be '\\' rather than '/'. Also, single byte space
4580   // characters are removed from the end of the path because those
4581   // are not legal ending characters on this operating system.
4582   //
4583   while (*src != '\0') {
4584     if (isfilesep(*src)) {
4585       *dst++ = '\\'; src++;
4586       while (isfilesep(*src)) src++;
4587       if (*src == '\0') {
4588         // Check for trailing separator
4589         end = dst;
4590         if (colon == dst - 2) break;  // "z:\\"
4591         if (dst == path + 1) break;   // "\\"
4592         if (dst == path + 2 && isfilesep(path[0])) {
4593           // "\\\\" is not collapsed to "\\" because "\\\\" marks the
4594           // beginning of a UNC pathname.  Even though it is not, by
4595           // itself, a valid UNC pathname, we leave it as is in order
4596           // to be consistent with the path canonicalizer as well
4597           // as the win32 APIs, which treat this case as an invalid
4598           // UNC pathname rather than as an alias for the root
4599           // directory of the current drive.
4600           break;
4601         }
4602         end = --dst;  // Path does not denote a root directory, so
4603                       // remove trailing separator
4604         break;
4605       }
4606       end = dst;
4607     } else {
4608       if (::IsDBCSLeadByte(*src)) {  // Copy a double-byte character
4609         *dst++ = *src++;
4610         if (*src) *dst++ = *src++;
4611         end = dst;
4612       } else {  // Copy a single-byte character
4613         char c = *src++;
4614         *dst++ = c;
4615         // Space is not a legal ending character
4616         if (c != ' ') end = dst;
4617       }
4618     }
4619   }
4620 
4621   *end = '\0';
4622 
4623   // For "z:", add "." to work around a bug in the C runtime library
4624   if (colon == dst - 1) {
4625     path[2] = '.';
4626     path[3] = '\0';
4627   }
4628 
4629   return path;
4630 }
4631 
4632 // This code is a copy of JDK's sysSetLength
4633 // from src/windows/hpi/src/sys_api_md.c
4634 
4635 int os::ftruncate(int fd, jlong length) {
4636   HANDLE h = (HANDLE)::_get_osfhandle(fd);
4637   long high = (long)(length >> 32);
4638   DWORD ret;
4639 
4640   if (h == (HANDLE)(-1)) {
4641     return -1;
4642   }
4643 
4644   ret = ::SetFilePointer(h, (long)(length), &high, FILE_BEGIN);
4645   if ((ret == 0xFFFFFFFF) && (::GetLastError() != NO_ERROR)) {
4646     return -1;
4647   }
4648 
4649   if (::SetEndOfFile(h) == FALSE) {
4650     return -1;
4651   }
4652 
4653   return 0;
4654 }
4655 
4656 
4657 // This code is a copy of JDK's sysSync
4658 // from src/windows/hpi/src/sys_api_md.c
4659 // except for the legacy workaround for a bug in Win 98
4660 
4661 int os::fsync(int fd) {
4662   HANDLE handle = (HANDLE)::_get_osfhandle(fd);
4663 
4664   if ((!::FlushFileBuffers(handle)) &&
4665       (GetLastError() != ERROR_ACCESS_DENIED)) {
4666     // from winerror.h
4667     return -1;
4668   }
4669   return 0;
4670 }
4671 
4672 static int nonSeekAvailable(int, long *);
4673 static int stdinAvailable(int, long *);
4674 
4675 #define S_ISCHR(mode)   (((mode) & _S_IFCHR) == _S_IFCHR)
4676 #define S_ISFIFO(mode)  (((mode) & _S_IFIFO) == _S_IFIFO)
4677 
4678 // This code is a copy of JDK's sysAvailable
4679 // from src/windows/hpi/src/sys_api_md.c
4680 
4681 int os::available(int fd, jlong *bytes) {
4682   jlong cur, end;
4683   struct _stati64 stbuf64;
4684 
4685   if (::_fstati64(fd, &stbuf64) >= 0) {
4686     int mode = stbuf64.st_mode;
4687     if (S_ISCHR(mode) || S_ISFIFO(mode)) {
4688       int ret;
4689       long lpbytes;
4690       if (fd == 0) {
4691         ret = stdinAvailable(fd, &lpbytes);
4692       } else {
4693         ret = nonSeekAvailable(fd, &lpbytes);
4694       }
4695       (*bytes) = (jlong)(lpbytes);
4696       return ret;
4697     }
4698     if ((cur = ::_lseeki64(fd, 0L, SEEK_CUR)) == -1) {
4699       return FALSE;
4700     } else if ((end = ::_lseeki64(fd, 0L, SEEK_END)) == -1) {
4701       return FALSE;
4702     } else if (::_lseeki64(fd, cur, SEEK_SET) == -1) {
4703       return FALSE;
4704     }
4705     *bytes = end - cur;
4706     return TRUE;
4707   } else {
4708     return FALSE;
4709   }
4710 }
4711 
4712 // This code is a copy of JDK's nonSeekAvailable
4713 // from src/windows/hpi/src/sys_api_md.c
4714 
4715 static int nonSeekAvailable(int fd, long *pbytes) {
4716   // This is used for available on non-seekable devices
4717   // (like both named and anonymous pipes, such as pipes
4718   //  connected to an exec'd process).
4719   // Standard Input is a special case.
4720   HANDLE han;
4721 
4722   if ((han = (HANDLE) ::_get_osfhandle(fd)) == (HANDLE)(-1)) {
4723     return FALSE;
4724   }
4725 
4726   if (! ::PeekNamedPipe(han, NULL, 0, NULL, (LPDWORD)pbytes, NULL)) {
4727     // PeekNamedPipe fails when at EOF.  In that case we
4728     // simply make *pbytes = 0 which is consistent with the
4729     // behavior we get on Solaris when an fd is at EOF.
4730     // The only alternative is to raise an Exception,
4731     // which isn't really warranted.
4732     //
4733     if (::GetLastError() != ERROR_BROKEN_PIPE) {
4734       return FALSE;
4735     }
4736     *pbytes = 0;
4737   }
4738   return TRUE;
4739 }
4740 
4741 #define MAX_INPUT_EVENTS 2000
4742 
4743 // This code is a copy of JDK's stdinAvailable
4744 // from src/windows/hpi/src/sys_api_md.c
4745 
4746 static int stdinAvailable(int fd, long *pbytes) {
4747   HANDLE han;
4748   DWORD numEventsRead = 0;  // Number of events read from buffer
4749   DWORD numEvents = 0;      // Number of events in buffer
4750   DWORD i = 0;              // Loop index
4751   DWORD curLength = 0;      // Position marker
4752   DWORD actualLength = 0;   // Number of bytes readable
4753   BOOL error = FALSE;       // Error holder
4754   INPUT_RECORD *lpBuffer;   // Pointer to records of input events
4755 
4756   if ((han = ::GetStdHandle(STD_INPUT_HANDLE)) == INVALID_HANDLE_VALUE) {
4757     return FALSE;
4758   }
4759 
4760   // Construct an array of input records in the console buffer
4761   error = ::GetNumberOfConsoleInputEvents(han, &numEvents);
4762   if (error == 0) {
4763     return nonSeekAvailable(fd, pbytes);
4764   }
4765 
4766   // lpBuffer must fit into 64K or else PeekConsoleInput fails
4767   if (numEvents > MAX_INPUT_EVENTS) {
4768     numEvents = MAX_INPUT_EVENTS;
4769   }
4770 
4771   lpBuffer = (INPUT_RECORD *)os::malloc(numEvents * sizeof(INPUT_RECORD), mtInternal);
4772   if (lpBuffer == NULL) {
4773     return FALSE;
4774   }
4775 
4776   error = ::PeekConsoleInput(han, lpBuffer, numEvents, &numEventsRead);
4777   if (error == 0) {
4778     os::free(lpBuffer);
4779     return FALSE;
4780   }
4781 
4782   // Examine input records for the number of bytes available
4783   for (i=0; i<numEvents; i++) {
4784     if (lpBuffer[i].EventType == KEY_EVENT) {
4785 
4786       KEY_EVENT_RECORD *keyRecord = (KEY_EVENT_RECORD *)
4787                                       &(lpBuffer[i].Event);
4788       if (keyRecord->bKeyDown == TRUE) {
4789         CHAR *keyPressed = (CHAR *) &(keyRecord->uChar);
4790         curLength++;
4791         if (*keyPressed == '\r') {
4792           actualLength = curLength;
4793         }
4794       }
4795     }
4796   }
4797 
4798   if (lpBuffer != NULL) {
4799     os::free(lpBuffer);
4800   }
4801 
4802   *pbytes = (long) actualLength;
4803   return TRUE;
4804 }
4805 
4806 // Map a block of memory.
4807 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
4808                         char *addr, size_t bytes, bool read_only,
4809                         bool allow_exec) {
4810   HANDLE hFile;
4811   char* base;
4812 
4813   hFile = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, NULL,
4814                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
4815   if (hFile == NULL) {
4816     if (PrintMiscellaneous && Verbose) {
4817       DWORD err = GetLastError();
4818       tty->print_cr("CreateFile() failed: GetLastError->%ld.", err);
4819     }
4820     return NULL;
4821   }
4822 
4823   if (allow_exec) {
4824     // CreateFileMapping/MapViewOfFileEx can't map executable memory
4825     // unless it comes from a PE image (which the shared archive is not.)
4826     // Even VirtualProtect refuses to give execute access to mapped memory
4827     // that was not previously executable.
4828     //
4829     // Instead, stick the executable region in anonymous memory.  Yuck.
4830     // Penalty is that ~4 pages will not be shareable - in the future
4831     // we might consider DLLizing the shared archive with a proper PE
4832     // header so that mapping executable + sharing is possible.
4833 
4834     base = (char*) VirtualAlloc(addr, bytes, MEM_COMMIT | MEM_RESERVE,
4835                                 PAGE_READWRITE);
4836     if (base == NULL) {
4837       if (PrintMiscellaneous && Verbose) {
4838         DWORD err = GetLastError();
4839         tty->print_cr("VirtualAlloc() failed: GetLastError->%ld.", err);
4840       }
4841       CloseHandle(hFile);
4842       return NULL;
4843     }
4844 
4845     DWORD bytes_read;
4846     OVERLAPPED overlapped;
4847     overlapped.Offset = (DWORD)file_offset;
4848     overlapped.OffsetHigh = 0;
4849     overlapped.hEvent = NULL;
4850     // ReadFile guarantees that if the return value is true, the requested
4851     // number of bytes were read before returning.
4852     bool res = ReadFile(hFile, base, (DWORD)bytes, &bytes_read, &overlapped) != 0;
4853     if (!res) {
4854       if (PrintMiscellaneous && Verbose) {
4855         DWORD err = GetLastError();
4856         tty->print_cr("ReadFile() failed: GetLastError->%ld.", err);
4857       }
4858       release_memory(base, bytes);
4859       CloseHandle(hFile);
4860       return NULL;
4861     }
4862   } else {
4863     HANDLE hMap = CreateFileMapping(hFile, NULL, PAGE_WRITECOPY, 0, 0,
4864                                     NULL /* file_name */);
4865     if (hMap == NULL) {
4866       if (PrintMiscellaneous && Verbose) {
4867         DWORD err = GetLastError();
4868         tty->print_cr("CreateFileMapping() failed: GetLastError->%ld.", err);
4869       }
4870       CloseHandle(hFile);
4871       return NULL;
4872     }
4873 
4874     DWORD access = read_only ? FILE_MAP_READ : FILE_MAP_COPY;
4875     base = (char*)MapViewOfFileEx(hMap, access, 0, (DWORD)file_offset,
4876                                   (DWORD)bytes, addr);
4877     if (base == NULL) {
4878       if (PrintMiscellaneous && Verbose) {
4879         DWORD err = GetLastError();
4880         tty->print_cr("MapViewOfFileEx() failed: GetLastError->%ld.", err);
4881       }
4882       CloseHandle(hMap);
4883       CloseHandle(hFile);
4884       return NULL;
4885     }
4886 
4887     if (CloseHandle(hMap) == 0) {
4888       if (PrintMiscellaneous && Verbose) {
4889         DWORD err = GetLastError();
4890         tty->print_cr("CloseHandle(hMap) failed: GetLastError->%ld.", err);
4891       }
4892       CloseHandle(hFile);
4893       return base;
4894     }
4895   }
4896 
4897   if (allow_exec) {
4898     DWORD old_protect;
4899     DWORD exec_access = read_only ? PAGE_EXECUTE_READ : PAGE_EXECUTE_READWRITE;
4900     bool res = VirtualProtect(base, bytes, exec_access, &old_protect) != 0;
4901 
4902     if (!res) {
4903       if (PrintMiscellaneous && Verbose) {
4904         DWORD err = GetLastError();
4905         tty->print_cr("VirtualProtect() failed: GetLastError->%ld.", err);
4906       }
4907       // Don't consider this a hard error, on IA32 even if the
4908       // VirtualProtect fails, we should still be able to execute
4909       CloseHandle(hFile);
4910       return base;
4911     }
4912   }
4913 
4914   if (CloseHandle(hFile) == 0) {
4915     if (PrintMiscellaneous && Verbose) {
4916       DWORD err = GetLastError();
4917       tty->print_cr("CloseHandle(hFile) failed: GetLastError->%ld.", err);
4918     }
4919     return base;
4920   }
4921 
4922   return base;
4923 }
4924 
4925 
4926 // Remap a block of memory.
4927 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4928                           char *addr, size_t bytes, bool read_only,
4929                           bool allow_exec) {
4930   // This OS does not allow existing memory maps to be remapped so we
4931   // have to unmap the memory before we remap it.
4932   if (!os::unmap_memory(addr, bytes)) {
4933     return NULL;
4934   }
4935 
4936   // There is a very small theoretical window between the unmap_memory()
4937   // call above and the map_memory() call below where a thread in native
4938   // code may be able to access an address that is no longer mapped.
4939 
4940   return os::map_memory(fd, file_name, file_offset, addr, bytes,
4941                         read_only, allow_exec);
4942 }
4943 
4944 
4945 // Unmap a block of memory.
4946 // Returns true=success, otherwise false.
4947 
4948 bool os::pd_unmap_memory(char* addr, size_t bytes) {
4949   MEMORY_BASIC_INFORMATION mem_info;
4950   if (VirtualQuery(addr, &mem_info, sizeof(mem_info)) == 0) {
4951     if (PrintMiscellaneous && Verbose) {
4952       DWORD err = GetLastError();
4953       tty->print_cr("VirtualQuery() failed: GetLastError->%ld.", err);
4954     }
4955     return false;
4956   }
4957 
4958   // Executable memory was not mapped using CreateFileMapping/MapViewOfFileEx.
4959   // Instead, executable region was allocated using VirtualAlloc(). See
4960   // pd_map_memory() above.
4961   //
4962   // The following flags should match the 'exec_access' flages used for
4963   // VirtualProtect() in pd_map_memory().
4964   if (mem_info.Protect == PAGE_EXECUTE_READ ||
4965       mem_info.Protect == PAGE_EXECUTE_READWRITE) {
4966     return pd_release_memory(addr, bytes);
4967   }
4968 
4969   BOOL result = UnmapViewOfFile(addr);
4970   if (result == 0) {
4971     if (PrintMiscellaneous && Verbose) {
4972       DWORD err = GetLastError();
4973       tty->print_cr("UnmapViewOfFile() failed: GetLastError->%ld.", err);
4974     }
4975     return false;
4976   }
4977   return true;
4978 }
4979 
4980 void os::pause() {
4981   char filename[MAX_PATH];
4982   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4983     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4984   } else {
4985     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4986   }
4987 
4988   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4989   if (fd != -1) {
4990     struct stat buf;
4991     ::close(fd);
4992     while (::stat(filename, &buf) == 0) {
4993       Sleep(100);
4994     }
4995   } else {
4996     jio_fprintf(stderr,
4997                 "Could not open pause file '%s', continuing immediately.\n", filename);
4998   }
4999 }
5000 
5001 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
5002   assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
5003 }
5004 
5005 // See the caveats for this class in os_windows.hpp
5006 // Protects the callback call so that raised OS EXCEPTIONS causes a jump back
5007 // into this method and returns false. If no OS EXCEPTION was raised, returns
5008 // true.
5009 // The callback is supposed to provide the method that should be protected.
5010 //
5011 bool os::WatcherThreadCrashProtection::call(os::CrashProtectionCallback& cb) {
5012   assert(Thread::current()->is_Watcher_thread(), "Only for WatcherThread");
5013   assert(!WatcherThread::watcher_thread()->has_crash_protection(),
5014          "crash_protection already set?");
5015 
5016   bool success = true;
5017   __try {
5018     WatcherThread::watcher_thread()->set_crash_protection(this);
5019     cb.call();
5020   } __except(EXCEPTION_EXECUTE_HANDLER) {
5021     // only for protection, nothing to do
5022     success = false;
5023   }
5024   WatcherThread::watcher_thread()->set_crash_protection(NULL);
5025   return success;
5026 }
5027 
5028 // An Event wraps a win32 "CreateEvent" kernel handle.
5029 //
5030 // We have a number of choices regarding "CreateEvent" win32 handle leakage:
5031 //
5032 // 1:  When a thread dies return the Event to the EventFreeList, clear the ParkHandle
5033 //     field, and call CloseHandle() on the win32 event handle.  Unpark() would
5034 //     need to be modified to tolerate finding a NULL (invalid) win32 event handle.
5035 //     In addition, an unpark() operation might fetch the handle field, but the
5036 //     event could recycle between the fetch and the SetEvent() operation.
5037 //     SetEvent() would either fail because the handle was invalid, or inadvertently work,
5038 //     as the win32 handle value had been recycled.  In an ideal world calling SetEvent()
5039 //     on an stale but recycled handle would be harmless, but in practice this might
5040 //     confuse other non-Sun code, so it's not a viable approach.
5041 //
5042 // 2:  Once a win32 event handle is associated with an Event, it remains associated
5043 //     with the Event.  The event handle is never closed.  This could be construed
5044 //     as handle leakage, but only up to the maximum # of threads that have been extant
5045 //     at any one time.  This shouldn't be an issue, as windows platforms typically
5046 //     permit a process to have hundreds of thousands of open handles.
5047 //
5048 // 3:  Same as (1), but periodically, at stop-the-world time, rundown the EventFreeList
5049 //     and release unused handles.
5050 //
5051 // 4:  Add a CRITICAL_SECTION to the Event to protect LD+SetEvent from LD;ST(null);CloseHandle.
5052 //     It's not clear, however, that we wouldn't be trading one type of leak for another.
5053 //
5054 // 5.  Use an RCU-like mechanism (Read-Copy Update).
5055 //     Or perhaps something similar to Maged Michael's "Hazard pointers".
5056 //
5057 // We use (2).
5058 //
5059 // TODO-FIXME:
5060 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the objectmonitor implementation.
5061 // 2.  Consider wrapping the WaitForSingleObject(Ex) calls in SEH try/finally blocks
5062 //     to recover from (or at least detect) the dreaded Windows 841176 bug.
5063 // 3.  Collapse the interrupt_event, the JSR166 parker event, and the objectmonitor ParkEvent
5064 //     into a single win32 CreateEvent() handle.
5065 //
5066 // Assumption:
5067 //    Only one parker can exist on an event, which is why we allocate
5068 //    them per-thread. Multiple unparkers can coexist.
5069 //
5070 // _Event transitions in park()
5071 //   -1 => -1 : illegal
5072 //    1 =>  0 : pass - return immediately
5073 //    0 => -1 : block; then set _Event to 0 before returning
5074 //
5075 // _Event transitions in unpark()
5076 //    0 => 1 : just return
5077 //    1 => 1 : just return
5078 //   -1 => either 0 or 1; must signal target thread
5079 //         That is, we can safely transition _Event from -1 to either
5080 //         0 or 1.
5081 //
5082 // _Event serves as a restricted-range semaphore.
5083 //   -1 : thread is blocked, i.e. there is a waiter
5084 //    0 : neutral: thread is running or ready,
5085 //        could have been signaled after a wait started
5086 //    1 : signaled - thread is running or ready
5087 //
5088 // Another possible encoding of _Event would be with
5089 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5090 //
5091 
5092 int os::PlatformEvent::park(jlong Millis) {
5093   // Transitions for _Event:
5094   //   -1 => -1 : illegal
5095   //    1 =>  0 : pass - return immediately
5096   //    0 => -1 : block; then set _Event to 0 before returning
5097 
5098   guarantee(_ParkHandle != NULL , "Invariant");
5099   guarantee(Millis > 0          , "Invariant");
5100 
5101   // CONSIDER: defer assigning a CreateEvent() handle to the Event until
5102   // the initial park() operation.
5103   // Consider: use atomic decrement instead of CAS-loop
5104 
5105   int v;
5106   for (;;) {
5107     v = _Event;
5108     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5109   }
5110   guarantee((v == 0) || (v == 1), "invariant");
5111   if (v != 0) return OS_OK;
5112 
5113   // Do this the hard way by blocking ...
5114   // TODO: consider a brief spin here, gated on the success of recent
5115   // spin attempts by this thread.
5116   //
5117   // We decompose long timeouts into series of shorter timed waits.
5118   // Evidently large timo values passed in WaitForSingleObject() are problematic on some
5119   // versions of Windows.  See EventWait() for details.  This may be superstition.  Or not.
5120   // We trust the WAIT_TIMEOUT indication and don't track the elapsed wait time
5121   // with os::javaTimeNanos().  Furthermore, we assume that spurious returns from
5122   // ::WaitForSingleObject() caused by latent ::setEvent() operations will tend
5123   // to happen early in the wait interval.  Specifically, after a spurious wakeup (rv ==
5124   // WAIT_OBJECT_0 but _Event is still < 0) we don't bother to recompute Millis to compensate
5125   // for the already waited time.  This policy does not admit any new outcomes.
5126   // In the future, however, we might want to track the accumulated wait time and
5127   // adjust Millis accordingly if we encounter a spurious wakeup.
5128 
5129   const int MAXTIMEOUT = 0x10000000;
5130   DWORD rv = WAIT_TIMEOUT;
5131   while (_Event < 0 && Millis > 0) {
5132     DWORD prd = Millis;     // set prd = MAX (Millis, MAXTIMEOUT)
5133     if (Millis > MAXTIMEOUT) {
5134       prd = MAXTIMEOUT;
5135     }
5136     rv = ::WaitForSingleObject(_ParkHandle, prd);
5137     assert(rv == WAIT_OBJECT_0 || rv == WAIT_TIMEOUT, "WaitForSingleObject failed");
5138     if (rv == WAIT_TIMEOUT) {
5139       Millis -= prd;
5140     }
5141   }
5142   v = _Event;
5143   _Event = 0;
5144   // see comment at end of os::PlatformEvent::park() below:
5145   OrderAccess::fence();
5146   // If we encounter a nearly simultanous timeout expiry and unpark()
5147   // we return OS_OK indicating we awoke via unpark().
5148   // Implementor's license -- returning OS_TIMEOUT would be equally valid, however.
5149   return (v >= 0) ? OS_OK : OS_TIMEOUT;
5150 }
5151 
5152 void os::PlatformEvent::park() {
5153   // Transitions for _Event:
5154   //   -1 => -1 : illegal
5155   //    1 =>  0 : pass - return immediately
5156   //    0 => -1 : block; then set _Event to 0 before returning
5157 
5158   guarantee(_ParkHandle != NULL, "Invariant");
5159   // Invariant: Only the thread associated with the Event/PlatformEvent
5160   // may call park().
5161   // Consider: use atomic decrement instead of CAS-loop
5162   int v;
5163   for (;;) {
5164     v = _Event;
5165     if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
5166   }
5167   guarantee((v == 0) || (v == 1), "invariant");
5168   if (v != 0) return;
5169 
5170   // Do this the hard way by blocking ...
5171   // TODO: consider a brief spin here, gated on the success of recent
5172   // spin attempts by this thread.
5173   while (_Event < 0) {
5174     DWORD rv = ::WaitForSingleObject(_ParkHandle, INFINITE);
5175     assert(rv == WAIT_OBJECT_0, "WaitForSingleObject failed");
5176   }
5177 
5178   // Usually we'll find _Event == 0 at this point, but as
5179   // an optional optimization we clear it, just in case can
5180   // multiple unpark() operations drove _Event up to 1.
5181   _Event = 0;
5182   OrderAccess::fence();
5183   guarantee(_Event >= 0, "invariant");
5184 }
5185 
5186 void os::PlatformEvent::unpark() {
5187   guarantee(_ParkHandle != NULL, "Invariant");
5188 
5189   // Transitions for _Event:
5190   //    0 => 1 : just return
5191   //    1 => 1 : just return
5192   //   -1 => either 0 or 1; must signal target thread
5193   //         That is, we can safely transition _Event from -1 to either
5194   //         0 or 1.
5195   // See also: "Semaphores in Plan 9" by Mullender & Cox
5196   //
5197   // Note: Forcing a transition from "-1" to "1" on an unpark() means
5198   // that it will take two back-to-back park() calls for the owning
5199   // thread to block. This has the benefit of forcing a spurious return
5200   // from the first park() call after an unpark() call which will help
5201   // shake out uses of park() and unpark() without condition variables.
5202 
5203   if (Atomic::xchg(1, &_Event) >= 0) return;
5204 
5205   ::SetEvent(_ParkHandle);
5206 }
5207 
5208 
5209 // JSR166
5210 // -------------------------------------------------------
5211 
5212 // The Windows implementation of Park is very straightforward: Basic
5213 // operations on Win32 Events turn out to have the right semantics to
5214 // use them directly. We opportunistically resuse the event inherited
5215 // from Monitor.
5216 
5217 void Parker::park(bool isAbsolute, jlong time) {
5218   guarantee(_ParkEvent != NULL, "invariant");
5219   // First, demultiplex/decode time arguments
5220   if (time < 0) { // don't wait
5221     return;
5222   } else if (time == 0 && !isAbsolute) {
5223     time = INFINITE;
5224   } else if (isAbsolute) {
5225     time -= os::javaTimeMillis(); // convert to relative time
5226     if (time <= 0) {  // already elapsed
5227       return;
5228     }
5229   } else { // relative
5230     time /= 1000000;  // Must coarsen from nanos to millis
5231     if (time == 0) {  // Wait for the minimal time unit if zero
5232       time = 1;
5233     }
5234   }
5235 
5236   JavaThread* thread = JavaThread::current();
5237 
5238   // Don't wait if interrupted or already triggered
5239   if (Thread::is_interrupted(thread, false) ||
5240       WaitForSingleObject(_ParkEvent, 0) == WAIT_OBJECT_0) {
5241     ResetEvent(_ParkEvent);
5242     return;
5243   } else {
5244     ThreadBlockInVM tbivm(thread);
5245     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
5246     thread->set_suspend_equivalent();
5247 
5248     WaitForSingleObject(_ParkEvent, time);
5249     ResetEvent(_ParkEvent);
5250 
5251     // If externally suspended while waiting, re-suspend
5252     if (thread->handle_special_suspend_equivalent_condition()) {
5253       thread->java_suspend_self();
5254     }
5255   }
5256 }
5257 
5258 void Parker::unpark() {
5259   guarantee(_ParkEvent != NULL, "invariant");
5260   SetEvent(_ParkEvent);
5261 }
5262 
5263 // Run the specified command in a separate process. Return its exit value,
5264 // or -1 on failure (e.g. can't create a new process).
5265 int os::fork_and_exec(char* cmd) {
5266   STARTUPINFO si;
5267   PROCESS_INFORMATION pi;
5268 
5269   memset(&si, 0, sizeof(si));
5270   si.cb = sizeof(si);
5271   memset(&pi, 0, sizeof(pi));
5272   BOOL rslt = CreateProcess(NULL,   // executable name - use command line
5273                             cmd,    // command line
5274                             NULL,   // process security attribute
5275                             NULL,   // thread security attribute
5276                             TRUE,   // inherits system handles
5277                             0,      // no creation flags
5278                             NULL,   // use parent's environment block
5279                             NULL,   // use parent's starting directory
5280                             &si,    // (in) startup information
5281                             &pi);   // (out) process information
5282 
5283   if (rslt) {
5284     // Wait until child process exits.
5285     WaitForSingleObject(pi.hProcess, INFINITE);
5286 
5287     DWORD exit_code;
5288     GetExitCodeProcess(pi.hProcess, &exit_code);
5289 
5290     // Close process and thread handles.
5291     CloseHandle(pi.hProcess);
5292     CloseHandle(pi.hThread);
5293 
5294     return (int)exit_code;
5295   } else {
5296     return -1;
5297   }
5298 }
5299 
5300 //--------------------------------------------------------------------------------------------------
5301 // Non-product code
5302 
5303 static int mallocDebugIntervalCounter = 0;
5304 static int mallocDebugCounter = 0;
5305 bool os::check_heap(bool force) {
5306   if (++mallocDebugCounter < MallocVerifyStart && !force) return true;
5307   if (++mallocDebugIntervalCounter >= MallocVerifyInterval || force) {
5308     // Note: HeapValidate executes two hardware breakpoints when it finds something
5309     // wrong; at these points, eax contains the address of the offending block (I think).
5310     // To get to the exlicit error message(s) below, just continue twice.
5311     //
5312     // Note:  we want to check the CRT heap, which is not necessarily located in the
5313     // process default heap.
5314     HANDLE heap = (HANDLE) _get_heap_handle();
5315     if (!heap) {
5316       return true;
5317     }
5318 
5319     // If we fail to lock the heap, then gflags.exe has been used
5320     // or some other special heap flag has been set that prevents
5321     // locking. We don't try to walk a heap we can't lock.
5322     if (HeapLock(heap) != 0) {
5323       PROCESS_HEAP_ENTRY phe;
5324       phe.lpData = NULL;
5325       while (HeapWalk(heap, &phe) != 0) {
5326         if ((phe.wFlags & PROCESS_HEAP_ENTRY_BUSY) &&
5327             !HeapValidate(heap, 0, phe.lpData)) {
5328           tty->print_cr("C heap has been corrupted (time: %d allocations)", mallocDebugCounter);
5329           tty->print_cr("corrupted block near address %#x, length %d", phe.lpData, phe.cbData);
5330           HeapUnlock(heap);
5331           fatal("corrupted C heap");
5332         }
5333       }
5334       DWORD err = GetLastError();
5335       if (err != ERROR_NO_MORE_ITEMS && err != ERROR_CALL_NOT_IMPLEMENTED) {
5336         HeapUnlock(heap);
5337         fatal("heap walk aborted with error %d", err);
5338       }
5339       HeapUnlock(heap);
5340     }
5341     mallocDebugIntervalCounter = 0;
5342   }
5343   return true;
5344 }
5345 
5346 
5347 bool os::find(address addr, outputStream* st) {
5348   // Nothing yet
5349   return false;
5350 }
5351 
5352 LONG WINAPI os::win32::serialize_fault_filter(struct _EXCEPTION_POINTERS* e) {
5353   DWORD exception_code = e->ExceptionRecord->ExceptionCode;
5354 
5355   if (exception_code == EXCEPTION_ACCESS_VIOLATION) {
5356     JavaThread* thread = JavaThread::current();
5357     PEXCEPTION_RECORD exceptionRecord = e->ExceptionRecord;
5358     address addr = (address) exceptionRecord->ExceptionInformation[1];
5359 
5360     if (os::is_memory_serialize_page(thread, addr)) {
5361       return EXCEPTION_CONTINUE_EXECUTION;
5362     }
5363   }
5364 
5365   return EXCEPTION_CONTINUE_SEARCH;
5366 }
5367 
5368 // We don't build a headless jre for Windows
5369 bool os::is_headless_jre() { return false; }
5370 
5371 static jint initSock() {
5372   WSADATA wsadata;
5373 
5374   if (!os::WinSock2Dll::WinSock2Available()) {
5375     jio_fprintf(stderr, "Could not load Winsock (error: %d)\n",
5376                 ::GetLastError());
5377     return JNI_ERR;
5378   }
5379 
5380   if (os::WinSock2Dll::WSAStartup(MAKEWORD(2,2), &wsadata) != 0) {
5381     jio_fprintf(stderr, "Could not initialize Winsock (error: %d)\n",
5382                 ::GetLastError());
5383     return JNI_ERR;
5384   }
5385   return JNI_OK;
5386 }
5387 
5388 struct hostent* os::get_host_by_name(char* name) {
5389   return (struct hostent*)os::WinSock2Dll::gethostbyname(name);
5390 }
5391 
5392 int os::socket_close(int fd) {
5393   return ::closesocket(fd);
5394 }
5395 
5396 int os::socket(int domain, int type, int protocol) {
5397   return ::socket(domain, type, protocol);
5398 }
5399 
5400 int os::connect(int fd, struct sockaddr* him, socklen_t len) {
5401   return ::connect(fd, him, len);
5402 }
5403 
5404 int os::recv(int fd, char* buf, size_t nBytes, uint flags) {
5405   return ::recv(fd, buf, (int)nBytes, flags);
5406 }
5407 
5408 int os::send(int fd, char* buf, size_t nBytes, uint flags) {
5409   return ::send(fd, buf, (int)nBytes, flags);
5410 }
5411 
5412 int os::raw_send(int fd, char* buf, size_t nBytes, uint flags) {
5413   return ::send(fd, buf, (int)nBytes, flags);
5414 }
5415 
5416 // WINDOWS CONTEXT Flags for THREAD_SAMPLING
5417 #if defined(IA32)
5418   #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT | CONTEXT_EXTENDED_REGISTERS)
5419 #elif defined (AMD64)
5420   #define sampling_context_flags (CONTEXT_FULL | CONTEXT_FLOATING_POINT)
5421 #endif
5422 
5423 // returns true if thread could be suspended,
5424 // false otherwise
5425 static bool do_suspend(HANDLE* h) {
5426   if (h != NULL) {
5427     if (SuspendThread(*h) != ~0) {
5428       return true;
5429     }
5430   }
5431   return false;
5432 }
5433 
5434 // resume the thread
5435 // calling resume on an active thread is a no-op
5436 static void do_resume(HANDLE* h) {
5437   if (h != NULL) {
5438     ResumeThread(*h);
5439   }
5440 }
5441 
5442 // retrieve a suspend/resume context capable handle
5443 // from the tid. Caller validates handle return value.
5444 void get_thread_handle_for_extended_context(HANDLE* h,
5445                                             OSThread::thread_id_t tid) {
5446   if (h != NULL) {
5447     *h = OpenThread(THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, tid);
5448   }
5449 }
5450 
5451 // Thread sampling implementation
5452 //
5453 void os::SuspendedThreadTask::internal_do_task() {
5454   CONTEXT    ctxt;
5455   HANDLE     h = NULL;
5456 
5457   // get context capable handle for thread
5458   get_thread_handle_for_extended_context(&h, _thread->osthread()->thread_id());
5459 
5460   // sanity
5461   if (h == NULL || h == INVALID_HANDLE_VALUE) {
5462     return;
5463   }
5464 
5465   // suspend the thread
5466   if (do_suspend(&h)) {
5467     ctxt.ContextFlags = sampling_context_flags;
5468     // get thread context
5469     GetThreadContext(h, &ctxt);
5470     SuspendedThreadTaskContext context(_thread, &ctxt);
5471     // pass context to Thread Sampling impl
5472     do_task(context);
5473     // resume thread
5474     do_resume(&h);
5475   }
5476 
5477   // close handle
5478   CloseHandle(h);
5479 }
5480 
5481 
5482 // Kernel32 API
5483 typedef SIZE_T (WINAPI* GetLargePageMinimum_Fn)(void);
5484 typedef LPVOID (WINAPI *VirtualAllocExNuma_Fn)(HANDLE, LPVOID, SIZE_T, DWORD, DWORD, DWORD);
5485 typedef BOOL (WINAPI *GetNumaHighestNodeNumber_Fn)(PULONG);
5486 typedef BOOL (WINAPI *GetNumaNodeProcessorMask_Fn)(UCHAR, PULONGLONG);
5487 typedef USHORT (WINAPI* RtlCaptureStackBackTrace_Fn)(ULONG, ULONG, PVOID*, PULONG);
5488 
5489 GetLargePageMinimum_Fn      os::Kernel32Dll::_GetLargePageMinimum = NULL;
5490 VirtualAllocExNuma_Fn       os::Kernel32Dll::_VirtualAllocExNuma = NULL;
5491 GetNumaHighestNodeNumber_Fn os::Kernel32Dll::_GetNumaHighestNodeNumber = NULL;
5492 GetNumaNodeProcessorMask_Fn os::Kernel32Dll::_GetNumaNodeProcessorMask = NULL;
5493 RtlCaptureStackBackTrace_Fn os::Kernel32Dll::_RtlCaptureStackBackTrace = NULL;
5494 
5495 
5496 BOOL                        os::Kernel32Dll::initialized = FALSE;
5497 SIZE_T os::Kernel32Dll::GetLargePageMinimum() {
5498   assert(initialized && _GetLargePageMinimum != NULL,
5499          "GetLargePageMinimumAvailable() not yet called");
5500   return _GetLargePageMinimum();
5501 }
5502 
5503 BOOL os::Kernel32Dll::GetLargePageMinimumAvailable() {
5504   if (!initialized) {
5505     initialize();
5506   }
5507   return _GetLargePageMinimum != NULL;
5508 }
5509 
5510 BOOL os::Kernel32Dll::NumaCallsAvailable() {
5511   if (!initialized) {
5512     initialize();
5513   }
5514   return _VirtualAllocExNuma != NULL;
5515 }
5516 
5517 LPVOID os::Kernel32Dll::VirtualAllocExNuma(HANDLE hProc, LPVOID addr,
5518                                            SIZE_T bytes, DWORD flags,
5519                                            DWORD prot, DWORD node) {
5520   assert(initialized && _VirtualAllocExNuma != NULL,
5521          "NUMACallsAvailable() not yet called");
5522 
5523   return _VirtualAllocExNuma(hProc, addr, bytes, flags, prot, node);
5524 }
5525 
5526 BOOL os::Kernel32Dll::GetNumaHighestNodeNumber(PULONG ptr_highest_node_number) {
5527   assert(initialized && _GetNumaHighestNodeNumber != NULL,
5528          "NUMACallsAvailable() not yet called");
5529 
5530   return _GetNumaHighestNodeNumber(ptr_highest_node_number);
5531 }
5532 
5533 BOOL os::Kernel32Dll::GetNumaNodeProcessorMask(UCHAR node,
5534                                                PULONGLONG proc_mask) {
5535   assert(initialized && _GetNumaNodeProcessorMask != NULL,
5536          "NUMACallsAvailable() not yet called");
5537 
5538   return _GetNumaNodeProcessorMask(node, proc_mask);
5539 }
5540 
5541 USHORT os::Kernel32Dll::RtlCaptureStackBackTrace(ULONG FrameToSkip,
5542                                                  ULONG FrameToCapture,
5543                                                  PVOID* BackTrace,
5544                                                  PULONG BackTraceHash) {
5545   if (!initialized) {
5546     initialize();
5547   }
5548 
5549   if (_RtlCaptureStackBackTrace != NULL) {
5550     return _RtlCaptureStackBackTrace(FrameToSkip, FrameToCapture,
5551                                      BackTrace, BackTraceHash);
5552   } else {
5553     return 0;
5554   }
5555 }
5556 
5557 void os::Kernel32Dll::initializeCommon() {
5558   if (!initialized) {
5559     HMODULE handle = ::GetModuleHandle("Kernel32.dll");
5560     assert(handle != NULL, "Just check");
5561     _GetLargePageMinimum = (GetLargePageMinimum_Fn)::GetProcAddress(handle, "GetLargePageMinimum");
5562     _VirtualAllocExNuma = (VirtualAllocExNuma_Fn)::GetProcAddress(handle, "VirtualAllocExNuma");
5563     _GetNumaHighestNodeNumber = (GetNumaHighestNodeNumber_Fn)::GetProcAddress(handle, "GetNumaHighestNodeNumber");
5564     _GetNumaNodeProcessorMask = (GetNumaNodeProcessorMask_Fn)::GetProcAddress(handle, "GetNumaNodeProcessorMask");
5565     _RtlCaptureStackBackTrace = (RtlCaptureStackBackTrace_Fn)::GetProcAddress(handle, "RtlCaptureStackBackTrace");
5566     initialized = TRUE;
5567   }
5568 }
5569 
5570 bool os::start_debugging(char *buf, int buflen) {
5571   int len = (int)strlen(buf);
5572   char *p = &buf[len];
5573 
5574   jio_snprintf(p, buflen-len,
5575              "\n\n"
5576              "Do you want to debug the problem?\n\n"
5577              "To debug, attach Visual Studio to process %d; then switch to thread 0x%x\n"
5578              "Select 'Yes' to launch Visual Studio automatically (PATH must include msdev)\n"
5579              "Otherwise, select 'No' to abort...",
5580              os::current_process_id(), os::current_thread_id());
5581 
5582   bool yes = os::message_box("Unexpected Error", buf);
5583 
5584   if (yes) {
5585     // os::breakpoint() calls DebugBreak(), which causes a breakpoint
5586     // exception. If VM is running inside a debugger, the debugger will
5587     // catch the exception. Otherwise, the breakpoint exception will reach
5588     // the default windows exception handler, which can spawn a debugger and
5589     // automatically attach to the dying VM.
5590     os::breakpoint();
5591     yes = false;
5592   }
5593   return yes;
5594 }
5595 
5596 void os::Kernel32Dll::initialize() {
5597   initializeCommon();
5598 }
5599 
5600 
5601 // Kernel32 API
5602 inline BOOL os::Kernel32Dll::SwitchToThread() {
5603   return ::SwitchToThread();
5604 }
5605 
5606 inline BOOL os::Kernel32Dll::SwitchToThreadAvailable() {
5607   return true;
5608 }
5609 
5610 // Help tools
5611 inline BOOL os::Kernel32Dll::HelpToolsAvailable() {
5612   return true;
5613 }
5614 
5615 inline HANDLE os::Kernel32Dll::CreateToolhelp32Snapshot(DWORD dwFlags,
5616                                                         DWORD th32ProcessId) {
5617   return ::CreateToolhelp32Snapshot(dwFlags, th32ProcessId);
5618 }
5619 
5620 inline BOOL os::Kernel32Dll::Module32First(HANDLE hSnapshot,
5621                                            LPMODULEENTRY32 lpme) {
5622   return ::Module32First(hSnapshot, lpme);
5623 }
5624 
5625 inline BOOL os::Kernel32Dll::Module32Next(HANDLE hSnapshot,
5626                                           LPMODULEENTRY32 lpme) {
5627   return ::Module32Next(hSnapshot, lpme);
5628 }
5629 
5630 inline void os::Kernel32Dll::GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo) {
5631   ::GetNativeSystemInfo(lpSystemInfo);
5632 }
5633 
5634 // PSAPI API
5635 inline BOOL os::PSApiDll::EnumProcessModules(HANDLE hProcess,
5636                                              HMODULE *lpModule, DWORD cb,
5637                                              LPDWORD lpcbNeeded) {
5638   return ::EnumProcessModules(hProcess, lpModule, cb, lpcbNeeded);
5639 }
5640 
5641 inline DWORD os::PSApiDll::GetModuleFileNameEx(HANDLE hProcess,
5642                                                HMODULE hModule,
5643                                                LPTSTR lpFilename,
5644                                                DWORD nSize) {
5645   return ::GetModuleFileNameEx(hProcess, hModule, lpFilename, nSize);
5646 }
5647 
5648 inline BOOL os::PSApiDll::GetModuleInformation(HANDLE hProcess,
5649                                                HMODULE hModule,
5650                                                LPMODULEINFO lpmodinfo,
5651                                                DWORD cb) {
5652   return ::GetModuleInformation(hProcess, hModule, lpmodinfo, cb);
5653 }
5654 
5655 inline BOOL os::PSApiDll::PSApiAvailable() {
5656   return true;
5657 }
5658 
5659 
5660 // WinSock2 API
5661 inline BOOL os::WinSock2Dll::WSAStartup(WORD wVersionRequested,
5662                                         LPWSADATA lpWSAData) {
5663   return ::WSAStartup(wVersionRequested, lpWSAData);
5664 }
5665 
5666 inline struct hostent* os::WinSock2Dll::gethostbyname(const char *name) {
5667   return ::gethostbyname(name);
5668 }
5669 
5670 inline BOOL os::WinSock2Dll::WinSock2Available() {
5671   return true;
5672 }
5673 
5674 // Advapi API
5675 inline BOOL os::Advapi32Dll::AdjustTokenPrivileges(HANDLE TokenHandle,
5676                                                    BOOL DisableAllPrivileges,
5677                                                    PTOKEN_PRIVILEGES NewState,
5678                                                    DWORD BufferLength,
5679                                                    PTOKEN_PRIVILEGES PreviousState,
5680                                                    PDWORD ReturnLength) {
5681   return ::AdjustTokenPrivileges(TokenHandle, DisableAllPrivileges, NewState,
5682                                  BufferLength, PreviousState, ReturnLength);
5683 }
5684 
5685 inline BOOL os::Advapi32Dll::OpenProcessToken(HANDLE ProcessHandle,
5686                                               DWORD DesiredAccess,
5687                                               PHANDLE TokenHandle) {
5688   return ::OpenProcessToken(ProcessHandle, DesiredAccess, TokenHandle);
5689 }
5690 
5691 inline BOOL os::Advapi32Dll::LookupPrivilegeValue(LPCTSTR lpSystemName,
5692                                                   LPCTSTR lpName,
5693                                                   PLUID lpLuid) {
5694   return ::LookupPrivilegeValue(lpSystemName, lpName, lpLuid);
5695 }
5696 
5697 inline BOOL os::Advapi32Dll::AdvapiAvailable() {
5698   return true;
5699 }
5700 
5701 void* os::get_default_process_handle() {
5702   return (void*)GetModuleHandle(NULL);
5703 }
5704 
5705 // Builds a platform dependent Agent_OnLoad_<lib_name> function name
5706 // which is used to find statically linked in agents.
5707 // Additionally for windows, takes into account __stdcall names.
5708 // Parameters:
5709 //            sym_name: Symbol in library we are looking for
5710 //            lib_name: Name of library to look in, NULL for shared libs.
5711 //            is_absolute_path == true if lib_name is absolute path to agent
5712 //                                     such as "C:/a/b/L.dll"
5713 //            == false if only the base name of the library is passed in
5714 //               such as "L"
5715 char* os::build_agent_function_name(const char *sym_name, const char *lib_name,
5716                                     bool is_absolute_path) {
5717   char *agent_entry_name;
5718   size_t len;
5719   size_t name_len;
5720   size_t prefix_len = strlen(JNI_LIB_PREFIX);
5721   size_t suffix_len = strlen(JNI_LIB_SUFFIX);
5722   const char *start;
5723 
5724   if (lib_name != NULL) {
5725     len = name_len = strlen(lib_name);
5726     if (is_absolute_path) {
5727       // Need to strip path, prefix and suffix
5728       if ((start = strrchr(lib_name, *os::file_separator())) != NULL) {
5729         lib_name = ++start;
5730       } else {
5731         // Need to check for drive prefix
5732         if ((start = strchr(lib_name, ':')) != NULL) {
5733           lib_name = ++start;
5734         }
5735       }
5736       if (len <= (prefix_len + suffix_len)) {
5737         return NULL;
5738       }
5739       lib_name += prefix_len;
5740       name_len = strlen(lib_name) - suffix_len;
5741     }
5742   }
5743   len = (lib_name != NULL ? name_len : 0) + strlen(sym_name) + 2;
5744   agent_entry_name = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len, mtThread);
5745   if (agent_entry_name == NULL) {
5746     return NULL;
5747   }
5748   if (lib_name != NULL) {
5749     const char *p = strrchr(sym_name, '@');
5750     if (p != NULL && p != sym_name) {
5751       // sym_name == _Agent_OnLoad@XX
5752       strncpy(agent_entry_name, sym_name, (p - sym_name));
5753       agent_entry_name[(p-sym_name)] = '\0';
5754       // agent_entry_name == _Agent_OnLoad
5755       strcat(agent_entry_name, "_");
5756       strncat(agent_entry_name, lib_name, name_len);
5757       strcat(agent_entry_name, p);
5758       // agent_entry_name == _Agent_OnLoad_lib_name@XX
5759     } else {
5760       strcpy(agent_entry_name, sym_name);
5761       strcat(agent_entry_name, "_");
5762       strncat(agent_entry_name, lib_name, name_len);
5763     }
5764   } else {
5765     strcpy(agent_entry_name, sym_name);
5766   }
5767   return agent_entry_name;
5768 }
5769 
5770 #ifndef PRODUCT
5771 
5772 // test the code path in reserve_memory_special() that tries to allocate memory in a single
5773 // contiguous memory block at a particular address.
5774 // The test first tries to find a good approximate address to allocate at by using the same
5775 // method to allocate some memory at any address. The test then tries to allocate memory in
5776 // the vicinity (not directly after it to avoid possible by-chance use of that location)
5777 // This is of course only some dodgy assumption, there is no guarantee that the vicinity of
5778 // the previously allocated memory is available for allocation. The only actual failure
5779 // that is reported is when the test tries to allocate at a particular location but gets a
5780 // different valid one. A NULL return value at this point is not considered an error but may
5781 // be legitimate.
5782 // If -XX:+VerboseInternalVMTests is enabled, print some explanatory messages.
5783 void TestReserveMemorySpecial_test() {
5784   if (!UseLargePages) {
5785     if (VerboseInternalVMTests) {
5786       tty->print("Skipping test because large pages are disabled");
5787     }
5788     return;
5789   }
5790   // save current value of globals
5791   bool old_use_large_pages_individual_allocation = UseLargePagesIndividualAllocation;
5792   bool old_use_numa_interleaving = UseNUMAInterleaving;
5793 
5794   // set globals to make sure we hit the correct code path
5795   UseLargePagesIndividualAllocation = UseNUMAInterleaving = false;
5796 
5797   // do an allocation at an address selected by the OS to get a good one.
5798   const size_t large_allocation_size = os::large_page_size() * 4;
5799   char* result = os::reserve_memory_special(large_allocation_size, os::large_page_size(), NULL, false);
5800   if (result == NULL) {
5801     if (VerboseInternalVMTests) {
5802       tty->print("Failed to allocate control block with size " SIZE_FORMAT ". Skipping remainder of test.",
5803                           large_allocation_size);
5804     }
5805   } else {
5806     os::release_memory_special(result, large_allocation_size);
5807 
5808     // allocate another page within the recently allocated memory area which seems to be a good location. At least
5809     // we managed to get it once.
5810     const size_t expected_allocation_size = os::large_page_size();
5811     char* expected_location = result + os::large_page_size();
5812     char* actual_location = os::reserve_memory_special(expected_allocation_size, os::large_page_size(), expected_location, false);
5813     if (actual_location == NULL) {
5814       if (VerboseInternalVMTests) {
5815         tty->print("Failed to allocate any memory at " PTR_FORMAT " size " SIZE_FORMAT ". Skipping remainder of test.",
5816                             expected_location, large_allocation_size);
5817       }
5818     } else {
5819       // release memory
5820       os::release_memory_special(actual_location, expected_allocation_size);
5821       // only now check, after releasing any memory to avoid any leaks.
5822       assert(actual_location == expected_location,
5823              "Failed to allocate memory at requested location " PTR_FORMAT " of size " SIZE_FORMAT ", is " PTR_FORMAT " instead",
5824              expected_location, expected_allocation_size, actual_location);
5825     }
5826   }
5827 
5828   // restore globals
5829   UseLargePagesIndividualAllocation = old_use_large_pages_individual_allocation;
5830   UseNUMAInterleaving = old_use_numa_interleaving;
5831 }
5832 #endif // PRODUCT
5833 
5834 /*
5835   All the defined signal names for Windows.
5836 
5837   NOTE that not all of these names are accepted by FindSignal!
5838 
5839   For various reasons some of these may be rejected at runtime.
5840 
5841   Here are the names currently accepted by a user of sun.misc.Signal with
5842   1.4.1 (ignoring potential interaction with use of chaining, etc):
5843 
5844      (LIST TBD)
5845 
5846 */
5847 int os::get_signal_number(const char* name) {
5848   static const struct {
5849     char* name;
5850     int   number;
5851   } siglabels [] =
5852     // derived from version 6.0 VC98/include/signal.h
5853   {"ABRT",      SIGABRT,        // abnormal termination triggered by abort cl
5854   "FPE",        SIGFPE,         // floating point exception
5855   "SEGV",       SIGSEGV,        // segment violation
5856   "INT",        SIGINT,         // interrupt
5857   "TERM",       SIGTERM,        // software term signal from kill
5858   "BREAK",      SIGBREAK,       // Ctrl-Break sequence
5859   "ILL",        SIGILL};        // illegal instruction
5860   for(int i=0;i<sizeof(siglabels)/sizeof(struct siglabel);i++)
5861     if(!strcmp(name, siglabels[i].name))
5862       return siglabels[i].number;
5863   return -1;
5864 }
5865 
5866 // Fast current thread access
5867 
5868 int os::win32::_thread_ptr_offset = 0;
5869 
5870 static void call_wrapper_dummy() {}
5871 
5872 // We need to call the os_exception_wrapper once so that it sets
5873 // up the offset from FS of the thread pointer.
5874 void os::win32::initialize_thread_ptr_offset() {
5875   os::os_exception_wrapper((java_call_t)call_wrapper_dummy,
5876                            NULL, NULL, NULL, NULL);
5877 }