Ignore:
Timestamp:
Feb 13, 2012, 9:07:12 PM (9 years ago)
Author:
dmik
Message:

trunk: Merged in openjdk6 b24 from branches/vendor/oracle.

Location:
trunk/openjdk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/openjdk

  • trunk/openjdk/hotspot/src/os/windows/vm/os_windows.cpp

    r297 r309  
    11/*
    2  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
     2 * CopyrighT (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
    33 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    44 *
     
    2828#endif
    2929
    30 // do not include precompiled header file
    31 # include "incls/_os_windows.cpp.incl"
     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
    3280
    3381#if defined(_DEBUG) && !defined(__WIN32OS2__)
     
    10511099}
    10521100
    1053 const char* os::dll_file_extension() { return ".dll"; }
    1054 
    10551101// This must be hard coded because it's the system's temporary
    10561102// directory not the java application's temp directory, ala java.io.tmpdir.
     
    10741120void os::dll_build_name(char *buffer, size_t buflen,
    10751121                        const char* pname, const char* fname) {
    1076   // Copied from libhpi
    10771122  const size_t pnamelen = pname ? strlen(pname) : 0;
    10781123  const char c = (pnamelen > 0) ? pname[pnamelen-1] : 0;
     
    13801425bool os::dll_address_to_function_name(address addr, char *buf,
    13811426                                      int buflen, int *offset) {
    1382   // Unimplemented on Windows - in order to use SymGetSymFromAddr(),
    1383   // we need to initialize imagehlp/dbghelp, then load symbol table
    1384   // for every module. That's too much work to do after a fatal error.
    1385   // For an example on how to implement this function, see 1.4.2.
    1386   if (offset)  *offset  = -1;
    1387   if (buf) buf[0] = '\0';
     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';
    13881432  return false;
    1389 }
    1390 
    1391 void* os::dll_lookup(void* handle, const char* name) {
    1392   return CAST_FROM_FN_PTR(void *, GetProcAddress((HMODULE)handle, name));
    13931433}
    13941434
     
    17531793  }
    17541794
     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') {
    17551821  GetModuleFileName(vm_lib_handle, buf, buflen);
     1822  }
    17561823  strcpy(saved_jvm_path, buf);
    17571824}
     
    17691836  st->print("@%d", args_size  * sizeof(int));
    17701837#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;
    17711876}
    17721877
     
    19832088  int   number;
    19842089};
     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
    19852100
    19862101struct siglabel exceptlabels[] = {
     
    20082123    def_excpt(EXCEPTION_GUARD_PAGE),
    20092124    def_excpt(EXCEPTION_INVALID_HANDLE),
     2125    def_excpt(EXCEPTION_UNCAUGHT_CXX_EXCEPTION),
    20102126    NULL, 0
    20112127};
     
    22402356    }
    22412357  }
    2242 
    22432358
    22442359  if (t != NULL && t->is_Java_thread()) {
     
    24452560    }
    24462561#ifndef _WIN64
    2447     if ((thread->thread_state() == _thread_in_Java) ||
    2448         (thread->thread_state() == _thread_in_native) )
     2562    if (((thread->thread_state() == _thread_in_Java) ||
     2563        (thread->thread_state() == _thread_in_native)) &&
     2564        exception_code != EXCEPTION_UNCAUGHT_CXX_EXCEPTION)
    24492565    {
    24502566      LONG result=Handle_FLT_Exception(exceptionInfo);
     
    24702586      case EXCEPTION_INT_OVERFLOW:
    24712587      case EXCEPTION_INT_DIVIDE_BY_ZERO:
     2588      case EXCEPTION_UNCAUGHT_CXX_EXCEPTION:
    24722589      {  report_error(t, exception_code, pc, exceptionInfo->ExceptionRecord,
    24732590                       exceptionInfo->ContextRecord);
     
    29983115  // >1: Thread is still suspended.
    29993116  assert(ret != SYS_THREAD_ERROR, "StartThread failed"); // should propagate back
    3000 }
    3001 
    3002 size_t os::read(int fd, void *buf, unsigned int nBytes) {
    3003   return ::read(fd, buf, nBytes);
    30043117}
    30053118
     
    34423555}
    34433556
    3444 
    34453557// this is called _after_ the global arguments have been parsed
    34463558jint os::init_2(void) {
     
    35153627  }
    35163628
    3517   // Initialize HPI.
    3518   jint hpi_result = hpi::initialize();
    3519   if (hpi_result != JNI_OK) { return hpi_result; }
    3520 
    35213629  // If stack_commit_size is 0, windows will reserve the default size,
    35223630  // but only commit a small portion of it.
     
    35273635    // If stack_commit_size == 0, we want this too
    35283636    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;
    35293652  }
    35303653
     
    36103733    return -1;
    36113734  }
    3612   hpi::native_path(strcpy(pathbuf, path));
     3735  os::native_path(strcpy(pathbuf, path));
    36133736  int ret = ::stat(pathbuf, sbuf);
    36143737  if (sbuf != NULL && UseUTCFileTimestamp) {
     
    37543877}
    37553878
     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
    37563893// Is a (classpath) directory empty?
    37573894bool os::dir_is_empty(const char* path) {
     
    37843921}
    37853922
     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}
    37864214
    37874215// Map a block of memory.
     
    39504378  if (fd != -1) {
    39514379    struct stat buf;
    3952     close(fd);
     4380    ::close(fd);
    39534381    while (::stat(filename, &buf) == 0) {
    39544382      Sleep(100);
     
    41334561    return;
    41344562  }
    4135   else if (time == 0) {
     4563  else if (time == 0 && !isAbsolute) {
    41364564    time = INFINITE;
    41374565  }
     
    43144742bool os::is_headless_jre() { return false; }
    43154743
     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 TracChangeset for help on using the changeset viewer.