source: trunk/openjdk/hotspot/src/os/windows/vm/os_windows.cpp @ 315

Last change on this file since 315 was 315, checked in by dmik, 9 years ago

Use TARGET_COMPILER_gcc instead of EMX when appropriate.

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