Adding upstream version 3.45.1.upstream/3.45.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1063 insertions, 0 deletions

diff --git a/ext/lsm1/lsm_win32.c b/ext/lsm1/lsm_win32.c
new file mode 100644
index 0000000..6c5d06b
--- /dev/null
+++ b/ext/lsm1/lsm_win32.c
@@ -0,0 +1,1063 @@
+/*
+** 2011-12-03
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+*************************************************************************
+**
+** Win32-specific run-time environment implementation for LSM.
+*/
+
+#ifdef _WIN32
+
+#include <assert.h>
+#include <string.h>
+
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include "windows.h"
+
+#include "lsmInt.h"
+
+/*
+** An open file is an instance of the following object
+*/
+typedef struct Win32File Win32File;
+struct Win32File {
+  lsm_env *pEnv;                  /* The run-time environment */
+  const char *zName;              /* Full path to file */
+
+  HANDLE hFile;                   /* Open file handle */
+  HANDLE hShmFile;                /* File handle for *-shm file */
+
+  SYSTEM_INFO sysInfo;            /* Operating system information */
+  HANDLE hMap;                    /* File handle for mapping */
+  LPVOID pMap;                    /* Pointer to mapping of file fd */
+  size_t nMap;                    /* Size of mapping at pMap in bytes */
+  int nShm;                       /* Number of entries in ahShm[]/apShm[] */
+  LPHANDLE ahShm;                 /* Array of handles for shared mappings */
+  LPVOID *apShm;                  /* Array of 32K shared memory segments */
+};
+
+static char *win32ShmFile(Win32File *pWin32File){
+  char *zShm;
+  int nName = strlen(pWin32File->zName);
+  zShm = (char *)lsmMallocZero(pWin32File->pEnv, nName+4+1);
+  if( zShm ){
+    memcpy(zShm, pWin32File->zName, nName);
+    memcpy(&zShm[nName], "-shm", 5);
+  }
+  return zShm;
+}
+
+static int win32Sleep(int us){
+  Sleep((us + 999) / 1000);
+  return LSM_OK;
+}
+
+/*
+** The number of times that an I/O operation will be retried following a
+** locking error - probably caused by antivirus software.  Also the initial
+** delay before the first retry.  The delay increases linearly with each
+** retry.
+*/
+#ifndef LSM_WIN32_IOERR_RETRY
+# define LSM_WIN32_IOERR_RETRY 10
+#endif
+#ifndef LSM_WIN32_IOERR_RETRY_DELAY
+# define LSM_WIN32_IOERR_RETRY_DELAY 25000
+#endif
+static int win32IoerrRetry = LSM_WIN32_IOERR_RETRY;
+static int win32IoerrRetryDelay = LSM_WIN32_IOERR_RETRY_DELAY;
+
+/*
+** The "win32IoerrCanRetry1" macro is used to determine if a particular
+** I/O error code obtained via GetLastError() is eligible to be retried.
+** It must accept the error code DWORD as its only argument and should
+** return non-zero if the error code is transient in nature and the
+** operation responsible for generating the original error might succeed
+** upon being retried.  The argument to this macro should be a variable.
+**
+** Additionally, a macro named "win32IoerrCanRetry2" may be defined.  If
+** it is defined, it will be consulted only when the macro
+** "win32IoerrCanRetry1" returns zero.  The "win32IoerrCanRetry2" macro
+** is completely optional and may be used to include additional error
+** codes in the set that should result in the failing I/O operation being
+** retried by the caller.  If defined, the "win32IoerrCanRetry2" macro
+** must exhibit external semantics identical to those of the
+** "win32IoerrCanRetry1" macro.
+*/
+#if !defined(win32IoerrCanRetry1)
+#define win32IoerrCanRetry1(a) (((a)==ERROR_ACCESS_DENIED)        || \
+                                ((a)==ERROR_SHARING_VIOLATION)    || \
+                                ((a)==ERROR_LOCK_VIOLATION)       || \
+                                ((a)==ERROR_DEV_NOT_EXIST)        || \
+                                ((a)==ERROR_NETNAME_DELETED)      || \
+                                ((a)==ERROR_SEM_TIMEOUT)          || \
+                                ((a)==ERROR_NETWORK_UNREACHABLE))
+#endif
+
+/*
+** If an I/O error occurs, invoke this routine to see if it should be
+** retried.  Return TRUE to retry.  Return FALSE to give up with an
+** error.
+*/
+static int win32RetryIoerr(
+  lsm_env *pEnv,
+  int *pnRetry
+){
+  DWORD lastErrno;
+  if( *pnRetry>=win32IoerrRetry ){
+    return 0;
+  }
+  lastErrno = GetLastError();
+  if( win32IoerrCanRetry1(lastErrno) ){
+    win32Sleep(win32IoerrRetryDelay*(1+*pnRetry));
+    ++*pnRetry;
+    return 1;
+  }
+#if defined(win32IoerrCanRetry2)
+  else if( win32IoerrCanRetry2(lastErrno) ){
+    win32Sleep(win32IoerrRetryDelay*(1+*pnRetry));
+    ++*pnRetry;
+    return 1;
+  }
+#endif
+  return 0;
+}
+
+/*
+** Convert a UTF-8 string to Microsoft Unicode.
+**
+** Space to hold the returned string is obtained from lsmMalloc().
+*/
+static LPWSTR win32Utf8ToUnicode(lsm_env *pEnv, const char *zText){
+  int nChar;
+  LPWSTR zWideText;
+
+  nChar = MultiByteToWideChar(CP_UTF8, 0, zText, -1, NULL, 0);
+  if( nChar==0 ){
+    return 0;
+  }
+  zWideText = lsmMallocZero(pEnv, nChar * sizeof(WCHAR));
+  if( zWideText==0 ){
+    return 0;
+  }
+  nChar = MultiByteToWideChar(CP_UTF8, 0, zText, -1, zWideText, nChar);
+  if( nChar==0 ){
+    lsmFree(pEnv, zWideText);
+    zWideText = 0;
+  }
+  return zWideText;
+}
+
+/*
+** Convert a Microsoft Unicode string to UTF-8.
+**
+** Space to hold the returned string is obtained from lsmMalloc().
+*/
+static char *win32UnicodeToUtf8(lsm_env *pEnv, LPCWSTR zWideText){
+  int nByte;
+  char *zText;
+
+  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideText, -1, 0, 0, 0, 0);
+  if( nByte == 0 ){
+    return 0;
+  }
+  zText = lsmMallocZero(pEnv, nByte);
+  if( zText==0 ){
+    return 0;
+  }
+  nByte = WideCharToMultiByte(CP_UTF8, 0, zWideText, -1, zText, nByte, 0, 0);
+  if( nByte == 0 ){
+    lsmFree(pEnv, zText);
+    zText = 0;
+  }
+  return zText;
+}
+
+#if !defined(win32IsNotFound)
+#define win32IsNotFound(a) (((a)==ERROR_FILE_NOT_FOUND)  || \
+                            ((a)==ERROR_PATH_NOT_FOUND))
+#endif
+
+static int win32Open(
+  lsm_env *pEnv,
+  const char *zFile,
+  int flags,
+  LPHANDLE phFile
+){
+  int rc;
+  LPWSTR zConverted;
+
+  zConverted = win32Utf8ToUnicode(pEnv, zFile);
+  if( zConverted==0 ){
+    rc = LSM_NOMEM_BKPT;
+  }else{
+    int bReadonly = (flags & LSM_OPEN_READONLY);
+    DWORD dwDesiredAccess;
+    DWORD dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    DWORD dwCreationDisposition;
+    DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
+    HANDLE hFile;
+    int nRetry = 0;
+    if( bReadonly ){
+      dwDesiredAccess = GENERIC_READ;
+      dwCreationDisposition = OPEN_EXISTING;
+    }else{
+      dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
+      dwCreationDisposition = OPEN_ALWAYS;
+    }
+    while( (hFile = CreateFileW((LPCWSTR)zConverted,
+                                dwDesiredAccess,
+                                dwShareMode, NULL,
+                                dwCreationDisposition,
+                                dwFlagsAndAttributes,
+                                NULL))==INVALID_HANDLE_VALUE &&
+                                win32RetryIoerr(pEnv, &nRetry) ){
+      /* Noop */
+    }
+    lsmFree(pEnv, zConverted);
+    if( hFile!=INVALID_HANDLE_VALUE ){
+      *phFile = hFile;
+      rc = LSM_OK;
+    }else{
+      if( win32IsNotFound(GetLastError()) ){
+        rc = lsmErrorBkpt(LSM_IOERR_NOENT);
+      }else{
+        rc = LSM_IOERR_BKPT;
+      }
+    }
+  }
+  return rc;
+}
+
+static int lsmWin32OsOpen(
+  lsm_env *pEnv,
+  const char *zFile,
+  int flags,
+  lsm_file **ppFile
+){
+  int rc = LSM_OK;
+  Win32File *pWin32File;
+
+  pWin32File = lsmMallocZero(pEnv, sizeof(Win32File));
+  if( pWin32File==0 ){
+    rc = LSM_NOMEM_BKPT;
+  }else{
+    HANDLE hFile = NULL;
+
+    rc = win32Open(pEnv, zFile, flags, &hFile);
+    if( rc==LSM_OK ){
+      memset(&pWin32File->sysInfo, 0, sizeof(SYSTEM_INFO));
+      GetSystemInfo(&pWin32File->sysInfo);
+      pWin32File->pEnv = pEnv;
+      pWin32File->zName = zFile;
+      pWin32File->hFile = hFile;
+    }else{
+      lsmFree(pEnv, pWin32File);
+      pWin32File = 0;
+    }
+  }
+  *ppFile = (lsm_file *)pWin32File;
+  return rc;
+}
+
+static int lsmWin32OsWrite(
+  lsm_file *pFile, /* File to write to */
+  lsm_i64 iOff,    /* Offset to write to */
+  void *pData,     /* Write data from this buffer */
+  int nData        /* Bytes of data to write */
+){
+  Win32File *pWin32File = (Win32File *)pFile;
+  OVERLAPPED overlapped;  /* The offset for WriteFile. */
+  u8 *aRem = (u8 *)pData; /* Data yet to be written */
+  int nRem = nData;       /* Number of bytes yet to be written */
+  int nRetry = 0;         /* Number of retrys */
+
+  memset(&overlapped, 0, sizeof(OVERLAPPED));
+  overlapped.Offset = (LONG)(iOff & 0XFFFFFFFF);
+  overlapped.OffsetHigh = (LONG)((iOff>>32) & 0x7FFFFFFF);
+  while( nRem>0 ){
+    DWORD nWrite = 0; /* Bytes written using WriteFile */
+    if( !WriteFile(pWin32File->hFile, aRem, nRem, &nWrite, &overlapped) ){
+      if( win32RetryIoerr(pWin32File->pEnv, &nRetry) ) continue;
+      break;
+    }
+    assert( nWrite==0 || nWrite<=(DWORD)nRem );
+    if( nWrite==0 || nWrite>(DWORD)nRem ){
+      break;
+    }
+    iOff += nWrite;
+    overlapped.Offset = (LONG)(iOff & 0xFFFFFFFF);
+    overlapped.OffsetHigh = (LONG)((iOff>>32) & 0x7FFFFFFF);
+    aRem += nWrite;
+    nRem -= nWrite;
+  }
+  if( nRem!=0 ) return LSM_IOERR_BKPT;
+  return LSM_OK;
+}
+
+static int win32Truncate(
+  HANDLE hFile,
+  lsm_i64 nSize
+){
+  LARGE_INTEGER offset;
+  offset.QuadPart = nSize;
+  if( !SetFilePointerEx(hFile, offset, 0, FILE_BEGIN) ){
+    return LSM_IOERR_BKPT;
+  }
+  if (!SetEndOfFile(hFile) ){
+    return LSM_IOERR_BKPT;
+  }
+  return LSM_OK;
+}
+
+static int lsmWin32OsTruncate(
+  lsm_file *pFile, /* File to write to */
+  lsm_i64 nSize    /* Size to truncate file to */
+){
+  Win32File *pWin32File = (Win32File *)pFile;
+  return win32Truncate(pWin32File->hFile, nSize);
+}
+
+static int lsmWin32OsRead(
+  lsm_file *pFile, /* File to read from */
+  lsm_i64 iOff,    /* Offset to read from */
+  void *pData,     /* Read data into this buffer */
+  int nData        /* Bytes of data to read */
+){
+  Win32File *pWin32File = (Win32File *)pFile;
+  OVERLAPPED overlapped; /* The offset for ReadFile */
+  DWORD nRead = 0;       /* Bytes read using ReadFile */
+  int nRetry = 0;        /* Number of retrys */
+
+  memset(&overlapped, 0, sizeof(OVERLAPPED));
+  overlapped.Offset = (LONG)(iOff & 0XFFFFFFFF);
+  overlapped.OffsetHigh = (LONG)((iOff>>32) & 0X7FFFFFFF);
+  while( !ReadFile(pWin32File->hFile, pData, nData, &nRead, &overlapped) &&
+         GetLastError()!=ERROR_HANDLE_EOF ){
+    if( win32RetryIoerr(pWin32File->pEnv, &nRetry) ) continue;
+    return LSM_IOERR_BKPT;
+  }
+  if( nRead<(DWORD)nData ){
+    /* Unread parts of the buffer must be zero-filled */
+    memset(&((char*)pData)[nRead], 0, nData - nRead);
+  }
+  return LSM_OK;
+}
+
+static int lsmWin32OsSync(lsm_file *pFile){
+  int rc = LSM_OK;
+
+#ifndef LSM_NO_SYNC
+  Win32File *pWin32File = (Win32File *)pFile;
+
+  if( pWin32File->pMap!=NULL ){
+    if( !FlushViewOfFile(pWin32File->pMap, 0) ){
+      rc = LSM_IOERR_BKPT;
+    }
+  }
+  if( rc==LSM_OK && !FlushFileBuffers(pWin32File->hFile) ){
+    rc = LSM_IOERR_BKPT;
+  }
+#else
+  unused_parameter(pFile);
+#endif
+
+  return rc;
+}
+
+static int lsmWin32OsSectorSize(lsm_file *pFile){
+  return 512;
+}
+
+static void win32Unmap(Win32File *pWin32File){
+  if( pWin32File->pMap!=NULL ){
+    UnmapViewOfFile(pWin32File->pMap);
+    pWin32File->pMap = NULL;
+    pWin32File->nMap = 0;
+  }
+  if( pWin32File->hMap!=NULL ){
+    CloseHandle(pWin32File->hMap);
+    pWin32File->hMap = NULL;
+  }
+}
+
+static int lsmWin32OsRemap(
+  lsm_file *pFile,
+  lsm_i64 iMin,
+  void **ppOut,
+  lsm_i64 *pnOut
+){
+  Win32File *pWin32File = (Win32File *)pFile;
+
+  /* If the file is between 0 and 2MB in size, extend it in chunks of 256K.
+  ** Thereafter, in chunks of 1MB at a time.  */
+  const int aIncrSz[] = {256*1024, 1024*1024};
+  int nIncrSz = aIncrSz[iMin>(2*1024*1024)];
+
+  *ppOut = NULL;
+  *pnOut = 0;
+
+  win32Unmap(pWin32File);
+  if( iMin>=0 ){
+    LARGE_INTEGER fileSize;
+    DWORD dwSizeHigh;
+    DWORD dwSizeLow;
+    HANDLE hMap;
+    LPVOID pMap;
+    memset(&fileSize, 0, sizeof(LARGE_INTEGER));
+    if( !GetFileSizeEx(pWin32File->hFile, &fileSize) ){
+      return LSM_IOERR_BKPT;
+    }
+    assert( fileSize.QuadPart>=0 );
+    if( fileSize.QuadPart<iMin ){
+      int rc;
+      fileSize.QuadPart = ((iMin + nIncrSz-1) / nIncrSz) * nIncrSz;
+      rc = lsmWin32OsTruncate(pFile, fileSize.QuadPart);
+      if( rc!=LSM_OK ){
+        return rc;
+      }
+    }
+    dwSizeLow = (DWORD)(fileSize.QuadPart & 0xFFFFFFFF);
+    dwSizeHigh = (DWORD)((fileSize.QuadPart & 0x7FFFFFFFFFFFFFFF) >> 32);
+    hMap = CreateFileMappingW(pWin32File->hFile, NULL, PAGE_READWRITE,
+                              dwSizeHigh, dwSizeLow, NULL);
+    if( hMap==NULL ){
+      return LSM_IOERR_BKPT;
+    }
+    pWin32File->hMap = hMap;
+    assert( fileSize.QuadPart<=0xFFFFFFFF );
+    pMap = MapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ, 0, 0,
+                         (SIZE_T)fileSize.QuadPart);
+    if( pMap==NULL ){
+      return LSM_IOERR_BKPT;
+    }
+    pWin32File->pMap = pMap;
+    pWin32File->nMap = (SIZE_T)fileSize.QuadPart;
+  }
+  *ppOut = pWin32File->pMap;
+  *pnOut = pWin32File->nMap;
+  return LSM_OK;
+}
+
+static BOOL win32IsDriveLetterAndColon(
+  const char *zPathname
+){
+  return ( isalpha(zPathname[0]) && zPathname[1]==':' );
+}
+
+static int lsmWin32OsFullpath(
+  lsm_env *pEnv,
+  const char *zName,
+  char *zOut,
+  int *pnOut
+){
+  DWORD nByte;
+  void *zConverted;
+  LPWSTR zTempWide;
+  char *zTempUtf8;
+
+  if( zName[0]=='/' && win32IsDriveLetterAndColon(zName+1) ){
+    zName++;
+  }
+  zConverted = win32Utf8ToUnicode(pEnv, zName);
+  if( zConverted==0 ){
+    return LSM_NOMEM_BKPT;
+  }
+  nByte = GetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0);
+  if( nByte==0 ){
+    lsmFree(pEnv, zConverted);
+    return LSM_IOERR_BKPT;
+  }
+  nByte += 3;
+  zTempWide = lsmMallocZero(pEnv, nByte * sizeof(zTempWide[0]));
+  if( zTempWide==0 ){
+    lsmFree(pEnv, zConverted);
+    return LSM_NOMEM_BKPT;
+  }
+  nByte = GetFullPathNameW((LPCWSTR)zConverted, nByte, zTempWide, 0);
+  if( nByte==0 ){
+    lsmFree(pEnv, zConverted);
+    lsmFree(pEnv, zTempWide);
+    return LSM_IOERR_BKPT;
+  }
+  lsmFree(pEnv, zConverted);
+  zTempUtf8 = win32UnicodeToUtf8(pEnv, zTempWide);
+  lsmFree(pEnv, zTempWide);
+  if( zTempUtf8 ){
+    int nOut = *pnOut;
+    int nLen = strlen(zTempUtf8) + 1;
+    if( nLen<=nOut ){
+      snprintf(zOut, nOut, "%s", zTempUtf8);
+    }
+    lsmFree(pEnv, zTempUtf8);
+    *pnOut = nLen;
+    return LSM_OK;
+  }else{
+    return LSM_NOMEM_BKPT;
+  }
+}
+
+static int lsmWin32OsFileid(
+  lsm_file *pFile,
+  void *pBuf,
+  int *pnBuf
+){
+  int nBuf;
+  int nReq;
+  u8 *pBuf2 = (u8 *)pBuf;
+  Win32File *pWin32File = (Win32File *)pFile;
+  BY_HANDLE_FILE_INFORMATION fileInfo;
+
+  nBuf = *pnBuf;
+  nReq = (sizeof(fileInfo.dwVolumeSerialNumber) +
+          sizeof(fileInfo.nFileIndexHigh) +
+          sizeof(fileInfo.nFileIndexLow));
+  *pnBuf = nReq;
+  if( nReq>nBuf ) return LSM_OK;
+  memset(&fileInfo, 0, sizeof(BY_HANDLE_FILE_INFORMATION));
+  if( !GetFileInformationByHandle(pWin32File->hFile, &fileInfo) ){
+    return LSM_IOERR_BKPT;
+  }
+  nReq = sizeof(fileInfo.dwVolumeSerialNumber);
+  memcpy(pBuf2, &fileInfo.dwVolumeSerialNumber, nReq);
+  pBuf2 += nReq;
+  nReq = sizeof(fileInfo.nFileIndexHigh);
+  memcpy(pBuf, &fileInfo.nFileIndexHigh, nReq);
+  pBuf2 += nReq;
+  nReq = sizeof(fileInfo.nFileIndexLow);
+  memcpy(pBuf2, &fileInfo.nFileIndexLow, nReq);
+  return LSM_OK;
+}
+
+static int win32Delete(
+  lsm_env *pEnv,
+  const char *zFile
+){
+  int rc;
+  LPWSTR zConverted;
+
+  zConverted = win32Utf8ToUnicode(pEnv, zFile);
+  if( zConverted==0 ){
+    rc = LSM_NOMEM_BKPT;
+  }else{
+    int nRetry = 0;
+    DWORD attr;
+
+    do {
+      attr = GetFileAttributesW(zConverted);
+      if ( attr==INVALID_FILE_ATTRIBUTES ){
+        rc = LSM_IOERR_BKPT;
+        break;
+      }
+      if ( attr&FILE_ATTRIBUTE_DIRECTORY ){
+        rc = LSM_IOERR_BKPT; /* Files only. */
+        break;
+      }
+      if ( DeleteFileW(zConverted) ){
+        rc = LSM_OK; /* Deleted OK. */
+        break;
+      }
+      if ( !win32RetryIoerr(pEnv, &nRetry) ){
+        rc = LSM_IOERR_BKPT; /* No more retries. */
+        break;
+      }
+    }while( 1 );
+  }
+  lsmFree(pEnv, zConverted);
+  return rc;
+}
+
+static int lsmWin32OsUnlink(lsm_env *pEnv, const char *zFile){
+  return win32Delete(pEnv, zFile);
+}
+
+#if !defined(win32IsLockBusy)
+#define win32IsLockBusy(a) (((a)==ERROR_LOCK_VIOLATION) || \
+                            ((a)==ERROR_IO_PENDING))
+#endif
+
+static int win32LockFile(
+  Win32File *pWin32File,
+  int iLock,
+  int nLock,
+  int eType
+){
+  OVERLAPPED ovlp;
+
+  assert( LSM_LOCK_UNLOCK==0 );
+  assert( LSM_LOCK_SHARED==1 );
+  assert( LSM_LOCK_EXCL==2 );
+  assert( eType>=LSM_LOCK_UNLOCK && eType<=LSM_LOCK_EXCL );
+  assert( nLock>=0 );
+  assert( iLock>0 && iLock<=32 );
+
+  memset(&ovlp, 0, sizeof(OVERLAPPED));
+  ovlp.Offset = (4096-iLock-nLock+1);
+  if( eType>LSM_LOCK_UNLOCK ){
+    DWORD flags = LOCKFILE_FAIL_IMMEDIATELY;
+    if( eType>=LSM_LOCK_EXCL ) flags |= LOCKFILE_EXCLUSIVE_LOCK;
+    if( !LockFileEx(pWin32File->hFile, flags, 0, (DWORD)nLock, 0, &ovlp) ){
+      if( win32IsLockBusy(GetLastError()) ){
+        return LSM_BUSY;
+      }else{
+        return LSM_IOERR_BKPT;
+      }
+    }
+  }else{
+    if( !UnlockFileEx(pWin32File->hFile, 0, (DWORD)nLock, 0, &ovlp) ){
+      return LSM_IOERR_BKPT;
+    }
+  }
+  return LSM_OK;
+}
+
+static int lsmWin32OsLock(lsm_file *pFile, int iLock, int eType){
+  Win32File *pWin32File = (Win32File *)pFile;
+  return win32LockFile(pWin32File, iLock, 1, eType);
+}
+
+static int lsmWin32OsTestLock(lsm_file *pFile, int iLock, int nLock, int eType){
+  int rc;
+  Win32File *pWin32File = (Win32File *)pFile;
+  rc = win32LockFile(pWin32File, iLock, nLock, eType);
+  if( rc!=LSM_OK ) return rc;
+  win32LockFile(pWin32File, iLock, nLock, LSM_LOCK_UNLOCK);
+  return LSM_OK;
+}
+
+static int lsmWin32OsShmMap(lsm_file *pFile, int iChunk, int sz, void **ppShm){
+  int rc;
+  Win32File *pWin32File = (Win32File *)pFile;
+  int iOffset = iChunk * sz;
+  int iOffsetShift = iOffset % pWin32File->sysInfo.dwAllocationGranularity;
+  int nNew = iChunk + 1;
+  lsm_i64 nReq = nNew * sz;
+
+  *ppShm = NULL;
+  assert( sz>=0 );
+  assert( sz==LSM_SHM_CHUNK_SIZE );
+  if( iChunk>=pWin32File->nShm ){
+    LPHANDLE ahNew;
+    LPVOID *apNew;
+    LARGE_INTEGER fileSize;
+
+    /* If the shared-memory file has not been opened, open it now. */
+    if( pWin32File->hShmFile==NULL ){
+      char *zShm = win32ShmFile(pWin32File);
+      if( !zShm ) return LSM_NOMEM_BKPT;
+      rc = win32Open(pWin32File->pEnv, zShm, 0, &pWin32File->hShmFile);
+      lsmFree(pWin32File->pEnv, zShm);
+      if( rc!=LSM_OK ){
+        return rc;
+      }
+    }
+
+    /* If the shared-memory file is not large enough to contain the
+    ** requested chunk, cause it to grow.  */
+    memset(&fileSize, 0, sizeof(LARGE_INTEGER));
+    if( !GetFileSizeEx(pWin32File->hShmFile, &fileSize) ){
+      return LSM_IOERR_BKPT;
+    }
+    assert( fileSize.QuadPart>=0 );
+    if( fileSize.QuadPart<nReq ){
+      rc = win32Truncate(pWin32File->hShmFile, nReq);
+      if( rc!=LSM_OK ){
+        return rc;
+      }
+    }
+
+    ahNew = (LPHANDLE)lsmMallocZero(pWin32File->pEnv, sizeof(HANDLE) * nNew);
+    if( !ahNew ) return LSM_NOMEM_BKPT;
+    apNew = (LPVOID *)lsmMallocZero(pWin32File->pEnv, sizeof(LPVOID) * nNew);
+    if( !apNew ){
+      lsmFree(pWin32File->pEnv, ahNew);
+      return LSM_NOMEM_BKPT;
+    }
+    memcpy(ahNew, pWin32File->ahShm, sizeof(HANDLE) * pWin32File->nShm);
+    memcpy(apNew, pWin32File->apShm, sizeof(LPVOID) * pWin32File->nShm);
+    lsmFree(pWin32File->pEnv, pWin32File->ahShm);
+    pWin32File->ahShm = ahNew;
+    lsmFree(pWin32File->pEnv, pWin32File->apShm);
+    pWin32File->apShm = apNew;
+    pWin32File->nShm = nNew;
+  }
+
+  if( pWin32File->ahShm[iChunk]==NULL ){
+    HANDLE hMap;
+    assert( nReq<=0xFFFFFFFF );
+    hMap = CreateFileMappingW(pWin32File->hShmFile, NULL, PAGE_READWRITE, 0,
+                              (DWORD)nReq, NULL);
+    if( hMap==NULL ){
+      return LSM_IOERR_BKPT;
+    }
+    pWin32File->ahShm[iChunk] = hMap;
+  }
+  if( pWin32File->apShm[iChunk]==NULL ){
+    LPVOID pMap;
+    pMap = MapViewOfFile(pWin32File->ahShm[iChunk],
+                         FILE_MAP_WRITE | FILE_MAP_READ, 0,
+                         iOffset - iOffsetShift, sz + iOffsetShift);
+    if( pMap==NULL ){
+      return LSM_IOERR_BKPT;
+    }
+    pWin32File->apShm[iChunk] = pMap;
+  }
+  if( iOffsetShift!=0 ){
+    char *p = (char *)pWin32File->apShm[iChunk];
+    *ppShm = (void *)&p[iOffsetShift];
+  }else{
+    *ppShm = pWin32File->apShm[iChunk];
+  }
+  return LSM_OK;
+}
+
+static void lsmWin32OsShmBarrier(void){
+  MemoryBarrier();
+}
+
+static int lsmWin32OsShmUnmap(lsm_file *pFile, int bDelete){
+  Win32File *pWin32File = (Win32File *)pFile;
+
+  if( pWin32File->hShmFile!=NULL ){
+    int i;
+    for(i=0; i<pWin32File->nShm; i++){
+      if( pWin32File->apShm[i]!=NULL ){
+        UnmapViewOfFile(pWin32File->apShm[i]);
+        pWin32File->apShm[i] = NULL;
+      }
+      if( pWin32File->ahShm[i]!=NULL ){
+        CloseHandle(pWin32File->ahShm[i]);
+        pWin32File->ahShm[i] = NULL;
+      }
+    }
+    CloseHandle(pWin32File->hShmFile);
+    pWin32File->hShmFile = NULL;
+    if( bDelete ){
+      char *zShm = win32ShmFile(pWin32File);
+      if( zShm ){ win32Delete(pWin32File->pEnv, zShm); }
+      lsmFree(pWin32File->pEnv, zShm);
+    }
+  }
+  return LSM_OK;
+}
+
+#define MX_CLOSE_ATTEMPT 3
+static int lsmWin32OsClose(lsm_file *pFile){
+  int rc;
+  int nRetry = 0;
+  Win32File *pWin32File = (Win32File *)pFile;
+  lsmWin32OsShmUnmap(pFile, 0);
+  win32Unmap(pWin32File);
+  do{
+    if( pWin32File->hFile==NULL ){
+      rc = LSM_IOERR_BKPT;
+      break;
+    }
+    rc = CloseHandle(pWin32File->hFile);
+    if( rc ){
+      pWin32File->hFile = NULL;
+      rc = LSM_OK;
+      break;
+    }
+    if( ++nRetry>=MX_CLOSE_ATTEMPT ){
+      rc = LSM_IOERR_BKPT;
+      break;
+    }
+  }while( 1 );
+  lsmFree(pWin32File->pEnv, pWin32File->ahShm);
+  lsmFree(pWin32File->pEnv, pWin32File->apShm);
+  lsmFree(pWin32File->pEnv, pWin32File);
+  return rc;
+}
+
+static int lsmWin32OsSleep(lsm_env *pEnv, int us){
+  unused_parameter(pEnv);
+  return win32Sleep(us);
+}
+
+/****************************************************************************
+** Memory allocation routines.
+*/
+
+static void *lsmWin32OsMalloc(lsm_env *pEnv, size_t N){
+  assert( HeapValidate(GetProcessHeap(), 0, NULL) );
+  return HeapAlloc(GetProcessHeap(), 0, (SIZE_T)N);
+}
+
+static void lsmWin32OsFree(lsm_env *pEnv, void *p){
+  assert( HeapValidate(GetProcessHeap(), 0, NULL) );
+  if( p ){
+    HeapFree(GetProcessHeap(), 0, p);
+  }
+}
+
+static void *lsmWin32OsRealloc(lsm_env *pEnv, void *p, size_t N){
+  unsigned char *m = (unsigned char *)p;
+  assert( HeapValidate(GetProcessHeap(), 0, NULL) );
+  if( 1>N ){
+    lsmWin32OsFree(pEnv, p);
+    return NULL;
+  }else if( NULL==p ){
+    return lsmWin32OsMalloc(pEnv, N);
+  }else{
+#if 0 /* arguable: don't shrink */
+    SIZE_T sz = HeapSize(GetProcessHeap(), 0, m);
+    if( sz>=(SIZE_T)N ){
+      return p;
+    }
+#endif
+    return HeapReAlloc(GetProcessHeap(), 0, m, N);
+  }
+}
+
+static size_t lsmWin32OsMSize(lsm_env *pEnv, void *p){
+  assert( HeapValidate(GetProcessHeap(), 0, NULL) );
+  return (size_t)HeapSize(GetProcessHeap(), 0, p);
+}
+
+
+#ifdef LSM_MUTEX_WIN32
+/*************************************************************************
+** Mutex methods for Win32 based systems.  If LSM_MUTEX_WIN32 is
+** missing then a no-op implementation of mutexes found below will be
+** used instead.
+*/
+#include "windows.h"
+
+typedef struct Win32Mutex Win32Mutex;
+struct Win32Mutex {
+  lsm_env *pEnv;
+  CRITICAL_SECTION mutex;
+#ifdef LSM_DEBUG
+  DWORD owner;
+#endif
+};
+
+#ifndef WIN32_MUTEX_INITIALIZER
+# define WIN32_MUTEX_INITIALIZER { 0 }
+#endif
+
+#ifdef LSM_DEBUG
+# define LSM_WIN32_STATIC_MUTEX { 0, WIN32_MUTEX_INITIALIZER, 0 }
+#else
+# define LSM_WIN32_STATIC_MUTEX { 0, WIN32_MUTEX_INITIALIZER }
+#endif
+
+static int lsmWin32OsMutexStatic(
+  lsm_env *pEnv,
+  int iMutex,
+  lsm_mutex **ppStatic
+){
+  static volatile LONG initialized = 0;
+  static Win32Mutex sMutex[2] = {
+    LSM_WIN32_STATIC_MUTEX,
+    LSM_WIN32_STATIC_MUTEX
+  };
+
+  assert( iMutex==LSM_MUTEX_GLOBAL || iMutex==LSM_MUTEX_HEAP );
+  assert( LSM_MUTEX_GLOBAL==1 && LSM_MUTEX_HEAP==2 );
+
+  if( InterlockedCompareExchange(&initialized, 1, 0)==0 ){
+    int i;
+    for(i=0; i<array_size(sMutex); i++){
+      InitializeCriticalSection(&sMutex[i].mutex);
+    }
+  }
+  *ppStatic = (lsm_mutex *)&sMutex[iMutex-1];
+  return LSM_OK;
+}
+
+static int lsmWin32OsMutexNew(lsm_env *pEnv, lsm_mutex **ppNew){
+  Win32Mutex *pMutex;           /* Pointer to new mutex */
+
+  pMutex = (Win32Mutex *)lsmMallocZero(pEnv, sizeof(Win32Mutex));
+  if( !pMutex ) return LSM_NOMEM_BKPT;
+
+  pMutex->pEnv = pEnv;
+  InitializeCriticalSection(&pMutex->mutex);
+
+  *ppNew = (lsm_mutex *)pMutex;
+  return LSM_OK;
+}
+
+static void lsmWin32OsMutexDel(lsm_mutex *p){
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+  DeleteCriticalSection(&pMutex->mutex);
+  lsmFree(pMutex->pEnv, pMutex);
+}
+
+static void lsmWin32OsMutexEnter(lsm_mutex *p){
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+  EnterCriticalSection(&pMutex->mutex);
+
+#ifdef LSM_DEBUG
+  assert( pMutex->owner!=GetCurrentThreadId() );
+  pMutex->owner = GetCurrentThreadId();
+  assert( pMutex->owner==GetCurrentThreadId() );
+#endif
+}
+
+static int lsmWin32OsMutexTry(lsm_mutex *p){
+  BOOL bRet;
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+  bRet = TryEnterCriticalSection(&pMutex->mutex);
+#ifdef LSM_DEBUG
+  if( bRet ){
+    assert( pMutex->owner!=GetCurrentThreadId() );
+    pMutex->owner = GetCurrentThreadId();
+    assert( pMutex->owner==GetCurrentThreadId() );
+  }
+#endif
+  return !bRet;
+}
+
+static void lsmWin32OsMutexLeave(lsm_mutex *p){
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+#ifdef LSM_DEBUG
+  assert( pMutex->owner==GetCurrentThreadId() );
+  pMutex->owner = 0;
+  assert( pMutex->owner!=GetCurrentThreadId() );
+#endif
+  LeaveCriticalSection(&pMutex->mutex);
+}
+
+#ifdef LSM_DEBUG
+static int lsmWin32OsMutexHeld(lsm_mutex *p){
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+  return pMutex ? pMutex->owner==GetCurrentThreadId() : 1;
+}
+static int lsmWin32OsMutexNotHeld(lsm_mutex *p){
+  Win32Mutex *pMutex = (Win32Mutex *)p;
+  return pMutex ? pMutex->owner!=GetCurrentThreadId() : 1;
+}
+#endif
+/*
+** End of Win32 mutex implementation.
+*************************************************************************/
+#else
+/*************************************************************************
+** Noop mutex implementation
+*/
+typedef struct NoopMutex NoopMutex;
+struct NoopMutex {
+  lsm_env *pEnv;                  /* Environment handle (for xFree()) */
+  int bHeld;                      /* True if mutex is held */
+  int bStatic;                    /* True for a static mutex */
+};
+static NoopMutex aStaticNoopMutex[2] = {
+  {0, 0, 1},
+  {0, 0, 1},
+};
+
+static int lsmWin32OsMutexStatic(
+  lsm_env *pEnv,
+  int iMutex,
+  lsm_mutex **ppStatic
+){
+  assert( iMutex>=1 && iMutex<=(int)array_size(aStaticNoopMutex) );
+  *ppStatic = (lsm_mutex *)&aStaticNoopMutex[iMutex-1];
+  return LSM_OK;
+}
+static int lsmWin32OsMutexNew(lsm_env *pEnv, lsm_mutex **ppNew){
+  NoopMutex *p;
+  p = (NoopMutex *)lsmMallocZero(pEnv, sizeof(NoopMutex));
+  if( p ) p->pEnv = pEnv;
+  *ppNew = (lsm_mutex *)p;
+  return (p ? LSM_OK : LSM_NOMEM_BKPT);
+}
+static void lsmWin32OsMutexDel(lsm_mutex *pMutex)  {
+  NoopMutex *p = (NoopMutex *)pMutex;
+  assert( p->bStatic==0 && p->pEnv );
+  lsmFree(p->pEnv, p);
+}
+static void lsmWin32OsMutexEnter(lsm_mutex *pMutex){
+  NoopMutex *p = (NoopMutex *)pMutex;
+  assert( p->bHeld==0 );
+  p->bHeld = 1;
+}
+static int lsmWin32OsMutexTry(lsm_mutex *pMutex){
+  NoopMutex *p = (NoopMutex *)pMutex;
+  assert( p->bHeld==0 );
+  p->bHeld = 1;
+  return 0;
+}
+static void lsmWin32OsMutexLeave(lsm_mutex *pMutex){
+  NoopMutex *p = (NoopMutex *)pMutex;
+  assert( p->bHeld==1 );
+  p->bHeld = 0;
+}
+#ifdef LSM_DEBUG
+static int lsmWin32OsMutexHeld(lsm_mutex *pMutex){
+  NoopMutex *p = (NoopMutex *)pMutex;
+  return p ? p->bHeld : 1;
+}
+static int lsmWin32OsMutexNotHeld(lsm_mutex *pMutex){
+  NoopMutex *p = (NoopMutex *)pMutex;
+  return p ? !p->bHeld : 1;
+}
+#endif
+/***************************************************************************/
+#endif /* else LSM_MUTEX_NONE */
+
+/* Without LSM_DEBUG, the MutexHeld tests are never called */
+#ifndef LSM_DEBUG
+# define lsmWin32OsMutexHeld    0
+# define lsmWin32OsMutexNotHeld 0
+#endif
+
+lsm_env *lsm_default_env(void){
+  static lsm_env win32_env = {
+    sizeof(lsm_env),         /* nByte */
+    1,                       /* iVersion */
+    /***** file i/o ******************/
+    0,                       /* pVfsCtx */
+    lsmWin32OsFullpath,      /* xFullpath */
+    lsmWin32OsOpen,          /* xOpen */
+    lsmWin32OsRead,          /* xRead */
+    lsmWin32OsWrite,         /* xWrite */
+    lsmWin32OsTruncate,      /* xTruncate */
+    lsmWin32OsSync,          /* xSync */
+    lsmWin32OsSectorSize,    /* xSectorSize */
+    lsmWin32OsRemap,         /* xRemap */
+    lsmWin32OsFileid,        /* xFileid */
+    lsmWin32OsClose,         /* xClose */
+    lsmWin32OsUnlink,        /* xUnlink */
+    lsmWin32OsLock,          /* xLock */
+    lsmWin32OsTestLock,      /* xTestLock */
+    lsmWin32OsShmMap,        /* xShmMap */
+    lsmWin32OsShmBarrier,    /* xShmBarrier */
+    lsmWin32OsShmUnmap,      /* xShmUnmap */
+    /***** memory allocation *********/
+    0,                       /* pMemCtx */
+    lsmWin32OsMalloc,        /* xMalloc */
+    lsmWin32OsRealloc,       /* xRealloc */
+    lsmWin32OsFree,          /* xFree */
+    lsmWin32OsMSize,         /* xSize */
+    /***** mutexes *********************/
+    0,                       /* pMutexCtx */
+    lsmWin32OsMutexStatic,   /* xMutexStatic */
+    lsmWin32OsMutexNew,      /* xMutexNew */
+    lsmWin32OsMutexDel,      /* xMutexDel */
+    lsmWin32OsMutexEnter,    /* xMutexEnter */
+    lsmWin32OsMutexTry,      /* xMutexTry */
+    lsmWin32OsMutexLeave,    /* xMutexLeave */
+    lsmWin32OsMutexHeld,     /* xMutexHeld */
+    lsmWin32OsMutexNotHeld,  /* xMutexNotHeld */
+    /***** other *********************/
+    lsmWin32OsSleep,         /* xSleep */
+  };
+  return &win32_env;
+}
+
+#endif