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