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