| Index: third_party/sqlite/src/src/os_win.c
|
| diff --git a/third_party/sqlite/src/src/os_win.c b/third_party/sqlite/src/src/os_win.c
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..78e58b5645140184024a71bc1f4e4cac35ac2b6e
|
| --- /dev/null
|
| +++ b/third_party/sqlite/src/src/os_win.c
|
| @@ -0,0 +1,2794 @@
|
| +/*
|
| +** 2004 May 22
|
| +**
|
| +** 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.
|
| +**
|
| +******************************************************************************
|
| +**
|
| +** This file contains code that is specific to windows.
|
| +*/
|
| +#include "sqliteInt.h"
|
| +#if SQLITE_OS_WIN /* This file is used for windows only */
|
| +
|
| +
|
| +/*
|
| +** A Note About Memory Allocation:
|
| +**
|
| +** This driver uses malloc()/free() directly rather than going through
|
| +** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
|
| +** are designed for use on embedded systems where memory is scarce and
|
| +** malloc failures happen frequently. Win32 does not typically run on
|
| +** embedded systems, and when it does the developers normally have bigger
|
| +** problems to worry about than running out of memory. So there is not
|
| +** a compelling need to use the wrappers.
|
| +**
|
| +** But there is a good reason to not use the wrappers. If we use the
|
| +** wrappers then we will get simulated malloc() failures within this
|
| +** driver. And that causes all kinds of problems for our tests. We
|
| +** could enhance SQLite to deal with simulated malloc failures within
|
| +** the OS driver, but the code to deal with those failure would not
|
| +** be exercised on Linux (which does not need to malloc() in the driver)
|
| +** and so we would have difficulty writing coverage tests for that
|
| +** code. Better to leave the code out, we think.
|
| +**
|
| +** The point of this discussion is as follows: When creating a new
|
| +** OS layer for an embedded system, if you use this file as an example,
|
| +** avoid the use of malloc()/free(). Those routines work ok on windows
|
| +** desktops but not so well in embedded systems.
|
| +*/
|
| +
|
| +#include <winbase.h>
|
| +
|
| +#ifdef __CYGWIN__
|
| +# include <sys/cygwin.h>
|
| +#endif
|
| +
|
| +/*
|
| +** Macros used to determine whether or not to use threads.
|
| +*/
|
| +#if defined(THREADSAFE) && THREADSAFE
|
| +# define SQLITE_W32_THREADS 1
|
| +#endif
|
| +
|
| +/*
|
| +** Include code that is common to all os_*.c files
|
| +*/
|
| +#include "os_common.h"
|
| +
|
| +/*
|
| +** Some microsoft compilers lack this definition.
|
| +*/
|
| +#ifndef INVALID_FILE_ATTRIBUTES
|
| +# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
|
| +#endif
|
| +
|
| +/*
|
| +** Determine if we are dealing with WindowsCE - which has a much
|
| +** reduced API.
|
| +*/
|
| +#if SQLITE_OS_WINCE
|
| +# define AreFileApisANSI() 1
|
| +# define FormatMessageW(a,b,c,d,e,f,g) 0
|
| +#endif
|
| +
|
| +/* Forward references */
|
| +typedef struct winShm winShm; /* A connection to shared-memory */
|
| +typedef struct winShmNode winShmNode; /* A region of shared-memory */
|
| +
|
| +/*
|
| +** WinCE lacks native support for file locking so we have to fake it
|
| +** with some code of our own.
|
| +*/
|
| +#if SQLITE_OS_WINCE
|
| +typedef struct winceLock {
|
| + int nReaders; /* Number of reader locks obtained */
|
| + BOOL bPending; /* Indicates a pending lock has been obtained */
|
| + BOOL bReserved; /* Indicates a reserved lock has been obtained */
|
| + BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
|
| +} winceLock;
|
| +#endif
|
| +
|
| +/*
|
| +** The winFile structure is a subclass of sqlite3_file* specific to the win32
|
| +** portability layer.
|
| +*/
|
| +typedef struct winFile winFile;
|
| +struct winFile {
|
| + const sqlite3_io_methods *pMethod; /*** Must be first ***/
|
| + sqlite3_vfs *pVfs; /* The VFS used to open this file */
|
| + HANDLE h; /* Handle for accessing the file */
|
| + unsigned char locktype; /* Type of lock currently held on this file */
|
| + short sharedLockByte; /* Randomly chosen byte used as a shared lock */
|
| + DWORD lastErrno; /* The Windows errno from the last I/O error */
|
| + DWORD sectorSize; /* Sector size of the device file is on */
|
| + winShm *pShm; /* Instance of shared memory on this file */
|
| + const char *zPath; /* Full pathname of this file */
|
| + int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
|
| +#if SQLITE_OS_WINCE
|
| + WCHAR *zDeleteOnClose; /* Name of file to delete when closing */
|
| + HANDLE hMutex; /* Mutex used to control access to shared lock */
|
| + HANDLE hShared; /* Shared memory segment used for locking */
|
| + winceLock local; /* Locks obtained by this instance of winFile */
|
| + winceLock *shared; /* Global shared lock memory for the file */
|
| +#endif
|
| +};
|
| +
|
| +/*
|
| +** Forward prototypes.
|
| +*/
|
| +static int getSectorSize(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zRelative /* UTF-8 file name */
|
| +);
|
| +
|
| +/*
|
| +** The following variable is (normally) set once and never changes
|
| +** thereafter. It records whether the operating system is Win95
|
| +** or WinNT.
|
| +**
|
| +** 0: Operating system unknown.
|
| +** 1: Operating system is Win95.
|
| +** 2: Operating system is WinNT.
|
| +**
|
| +** In order to facilitate testing on a WinNT system, the test fixture
|
| +** can manually set this value to 1 to emulate Win98 behavior.
|
| +*/
|
| +#ifdef SQLITE_TEST
|
| +int sqlite3_os_type = 0;
|
| +#else
|
| +static int sqlite3_os_type = 0;
|
| +#endif
|
| +
|
| +/*
|
| +** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
|
| +** or WinCE. Return false (zero) for Win95, Win98, or WinME.
|
| +**
|
| +** Here is an interesting observation: Win95, Win98, and WinME lack
|
| +** the LockFileEx() API. But we can still statically link against that
|
| +** API as long as we don't call it when running Win95/98/ME. A call to
|
| +** this routine is used to determine if the host is Win95/98/ME or
|
| +** WinNT/2K/XP so that we will know whether or not we can safely call
|
| +** the LockFileEx() API.
|
| +*/
|
| +#if SQLITE_OS_WINCE
|
| +# define isNT() (1)
|
| +#else
|
| + static int isNT(void){
|
| + if( sqlite3_os_type==0 ){
|
| + OSVERSIONINFO sInfo;
|
| + sInfo.dwOSVersionInfoSize = sizeof(sInfo);
|
| + GetVersionEx(&sInfo);
|
| + sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
|
| + }
|
| + return sqlite3_os_type==2;
|
| + }
|
| +#endif /* SQLITE_OS_WINCE */
|
| +
|
| +/*
|
| +** Convert a UTF-8 string to microsoft unicode (UTF-16?).
|
| +**
|
| +** Space to hold the returned string is obtained from malloc.
|
| +*/
|
| +static WCHAR *utf8ToUnicode(const char *zFilename){
|
| + int nChar;
|
| + WCHAR *zWideFilename;
|
| +
|
| + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
|
| + zWideFilename = malloc( nChar*sizeof(zWideFilename[0]) );
|
| + if( zWideFilename==0 ){
|
| + return 0;
|
| + }
|
| + nChar = MultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename, nChar);
|
| + if( nChar==0 ){
|
| + free(zWideFilename);
|
| + zWideFilename = 0;
|
| + }
|
| + return zWideFilename;
|
| +}
|
| +
|
| +/*
|
| +** Convert microsoft unicode to UTF-8. Space to hold the returned string is
|
| +** obtained from malloc().
|
| +*/
|
| +static char *unicodeToUtf8(const WCHAR *zWideFilename){
|
| + int nByte;
|
| + char *zFilename;
|
| +
|
| + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
|
| + zFilename = malloc( nByte );
|
| + if( zFilename==0 ){
|
| + return 0;
|
| + }
|
| + nByte = WideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
|
| + 0, 0);
|
| + if( nByte == 0 ){
|
| + free(zFilename);
|
| + zFilename = 0;
|
| + }
|
| + return zFilename;
|
| +}
|
| +
|
| +/*
|
| +** Convert an ansi string to microsoft unicode, based on the
|
| +** current codepage settings for file apis.
|
| +**
|
| +** Space to hold the returned string is obtained
|
| +** from malloc.
|
| +*/
|
| +static WCHAR *mbcsToUnicode(const char *zFilename){
|
| + int nByte;
|
| + WCHAR *zMbcsFilename;
|
| + int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
|
| +
|
| + nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, NULL,0)*sizeof(WCHAR);
|
| + zMbcsFilename = malloc( nByte*sizeof(zMbcsFilename[0]) );
|
| + if( zMbcsFilename==0 ){
|
| + return 0;
|
| + }
|
| + nByte = MultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename, nByte);
|
| + if( nByte==0 ){
|
| + free(zMbcsFilename);
|
| + zMbcsFilename = 0;
|
| + }
|
| + return zMbcsFilename;
|
| +}
|
| +
|
| +/*
|
| +** Convert microsoft unicode to multibyte character string, based on the
|
| +** user's Ansi codepage.
|
| +**
|
| +** Space to hold the returned string is obtained from
|
| +** malloc().
|
| +*/
|
| +static char *unicodeToMbcs(const WCHAR *zWideFilename){
|
| + int nByte;
|
| + char *zFilename;
|
| + int codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
|
| +
|
| + nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
|
| + zFilename = malloc( nByte );
|
| + if( zFilename==0 ){
|
| + return 0;
|
| + }
|
| + nByte = WideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename, nByte,
|
| + 0, 0);
|
| + if( nByte == 0 ){
|
| + free(zFilename);
|
| + zFilename = 0;
|
| + }
|
| + return zFilename;
|
| +}
|
| +
|
| +/*
|
| +** Convert multibyte character string to UTF-8. Space to hold the
|
| +** returned string is obtained from malloc().
|
| +*/
|
| +char *sqlite3_win32_mbcs_to_utf8(const char *zFilename){
|
| + char *zFilenameUtf8;
|
| + WCHAR *zTmpWide;
|
| +
|
| + zTmpWide = mbcsToUnicode(zFilename);
|
| + if( zTmpWide==0 ){
|
| + return 0;
|
| + }
|
| + zFilenameUtf8 = unicodeToUtf8(zTmpWide);
|
| + free(zTmpWide);
|
| + return zFilenameUtf8;
|
| +}
|
| +
|
| +/*
|
| +** Convert UTF-8 to multibyte character string. Space to hold the
|
| +** returned string is obtained from malloc().
|
| +*/
|
| +static char *utf8ToMbcs(const char *zFilename){
|
| + char *zFilenameMbcs;
|
| + WCHAR *zTmpWide;
|
| +
|
| + zTmpWide = utf8ToUnicode(zFilename);
|
| + if( zTmpWide==0 ){
|
| + return 0;
|
| + }
|
| + zFilenameMbcs = unicodeToMbcs(zTmpWide);
|
| + free(zTmpWide);
|
| + return zFilenameMbcs;
|
| +}
|
| +
|
| +#if SQLITE_OS_WINCE
|
| +/*************************************************************************
|
| +** This section contains code for WinCE only.
|
| +*/
|
| +/*
|
| +** WindowsCE does not have a localtime() function. So create a
|
| +** substitute.
|
| +*/
|
| +#include <time.h>
|
| +struct tm *__cdecl localtime(const time_t *t)
|
| +{
|
| + static struct tm y;
|
| + FILETIME uTm, lTm;
|
| + SYSTEMTIME pTm;
|
| + sqlite3_int64 t64;
|
| + t64 = *t;
|
| + t64 = (t64 + 11644473600)*10000000;
|
| + uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
|
| + uTm.dwHighDateTime= (DWORD)(t64 >> 32);
|
| + FileTimeToLocalFileTime(&uTm,&lTm);
|
| + FileTimeToSystemTime(&lTm,&pTm);
|
| + y.tm_year = pTm.wYear - 1900;
|
| + y.tm_mon = pTm.wMonth - 1;
|
| + y.tm_wday = pTm.wDayOfWeek;
|
| + y.tm_mday = pTm.wDay;
|
| + y.tm_hour = pTm.wHour;
|
| + y.tm_min = pTm.wMinute;
|
| + y.tm_sec = pTm.wSecond;
|
| + return &y;
|
| +}
|
| +
|
| +/* This will never be called, but defined to make the code compile */
|
| +#define GetTempPathA(a,b)
|
| +
|
| +#define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e)
|
| +#define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e)
|
| +#define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f)
|
| +
|
| +#define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
|
| +
|
| +/*
|
| +** Acquire a lock on the handle h
|
| +*/
|
| +static void winceMutexAcquire(HANDLE h){
|
| + DWORD dwErr;
|
| + do {
|
| + dwErr = WaitForSingleObject(h, INFINITE);
|
| + } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
|
| +}
|
| +/*
|
| +** Release a lock acquired by winceMutexAcquire()
|
| +*/
|
| +#define winceMutexRelease(h) ReleaseMutex(h)
|
| +
|
| +/*
|
| +** Create the mutex and shared memory used for locking in the file
|
| +** descriptor pFile
|
| +*/
|
| +static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
|
| + WCHAR *zTok;
|
| + WCHAR *zName = utf8ToUnicode(zFilename);
|
| + BOOL bInit = TRUE;
|
| +
|
| + /* Initialize the local lockdata */
|
| + ZeroMemory(&pFile->local, sizeof(pFile->local));
|
| +
|
| + /* Replace the backslashes from the filename and lowercase it
|
| + ** to derive a mutex name. */
|
| + zTok = CharLowerW(zName);
|
| + for (;*zTok;zTok++){
|
| + if (*zTok == '\\') *zTok = '_';
|
| + }
|
| +
|
| + /* Create/open the named mutex */
|
| + pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
|
| + if (!pFile->hMutex){
|
| + pFile->lastErrno = GetLastError();
|
| + free(zName);
|
| + return FALSE;
|
| + }
|
| +
|
| + /* Acquire the mutex before continuing */
|
| + winceMutexAcquire(pFile->hMutex);
|
| +
|
| + /* Since the names of named mutexes, semaphores, file mappings etc are
|
| + ** case-sensitive, take advantage of that by uppercasing the mutex name
|
| + ** and using that as the shared filemapping name.
|
| + */
|
| + CharUpperW(zName);
|
| + pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
|
| + PAGE_READWRITE, 0, sizeof(winceLock),
|
| + zName);
|
| +
|
| + /* Set a flag that indicates we're the first to create the memory so it
|
| + ** must be zero-initialized */
|
| + if (GetLastError() == ERROR_ALREADY_EXISTS){
|
| + bInit = FALSE;
|
| + }
|
| +
|
| + free(zName);
|
| +
|
| + /* If we succeeded in making the shared memory handle, map it. */
|
| + if (pFile->hShared){
|
| + pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared,
|
| + FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
|
| + /* If mapping failed, close the shared memory handle and erase it */
|
| + if (!pFile->shared){
|
| + pFile->lastErrno = GetLastError();
|
| + CloseHandle(pFile->hShared);
|
| + pFile->hShared = NULL;
|
| + }
|
| + }
|
| +
|
| + /* If shared memory could not be created, then close the mutex and fail */
|
| + if (pFile->hShared == NULL){
|
| + winceMutexRelease(pFile->hMutex);
|
| + CloseHandle(pFile->hMutex);
|
| + pFile->hMutex = NULL;
|
| + return FALSE;
|
| + }
|
| +
|
| + /* Initialize the shared memory if we're supposed to */
|
| + if (bInit) {
|
| + ZeroMemory(pFile->shared, sizeof(winceLock));
|
| + }
|
| +
|
| + winceMutexRelease(pFile->hMutex);
|
| + return TRUE;
|
| +}
|
| +
|
| +/*
|
| +** Destroy the part of winFile that deals with wince locks
|
| +*/
|
| +static void winceDestroyLock(winFile *pFile){
|
| + if (pFile->hMutex){
|
| + /* Acquire the mutex */
|
| + winceMutexAcquire(pFile->hMutex);
|
| +
|
| + /* The following blocks should probably assert in debug mode, but they
|
| + are to cleanup in case any locks remained open */
|
| + if (pFile->local.nReaders){
|
| + pFile->shared->nReaders --;
|
| + }
|
| + if (pFile->local.bReserved){
|
| + pFile->shared->bReserved = FALSE;
|
| + }
|
| + if (pFile->local.bPending){
|
| + pFile->shared->bPending = FALSE;
|
| + }
|
| + if (pFile->local.bExclusive){
|
| + pFile->shared->bExclusive = FALSE;
|
| + }
|
| +
|
| + /* De-reference and close our copy of the shared memory handle */
|
| + UnmapViewOfFile(pFile->shared);
|
| + CloseHandle(pFile->hShared);
|
| +
|
| + /* Done with the mutex */
|
| + winceMutexRelease(pFile->hMutex);
|
| + CloseHandle(pFile->hMutex);
|
| + pFile->hMutex = NULL;
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** An implementation of the LockFile() API of windows for wince
|
| +*/
|
| +static BOOL winceLockFile(
|
| + HANDLE *phFile,
|
| + DWORD dwFileOffsetLow,
|
| + DWORD dwFileOffsetHigh,
|
| + DWORD nNumberOfBytesToLockLow,
|
| + DWORD nNumberOfBytesToLockHigh
|
| +){
|
| + winFile *pFile = HANDLE_TO_WINFILE(phFile);
|
| + BOOL bReturn = FALSE;
|
| +
|
| + UNUSED_PARAMETER(dwFileOffsetHigh);
|
| + UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
|
| +
|
| + if (!pFile->hMutex) return TRUE;
|
| + winceMutexAcquire(pFile->hMutex);
|
| +
|
| + /* Wanting an exclusive lock? */
|
| + if (dwFileOffsetLow == (DWORD)SHARED_FIRST
|
| + && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
|
| + if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
|
| + pFile->shared->bExclusive = TRUE;
|
| + pFile->local.bExclusive = TRUE;
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + /* Want a read-only lock? */
|
| + else if (dwFileOffsetLow == (DWORD)SHARED_FIRST &&
|
| + nNumberOfBytesToLockLow == 1){
|
| + if (pFile->shared->bExclusive == 0){
|
| + pFile->local.nReaders ++;
|
| + if (pFile->local.nReaders == 1){
|
| + pFile->shared->nReaders ++;
|
| + }
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + /* Want a pending lock? */
|
| + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToLockLow == 1){
|
| + /* If no pending lock has been acquired, then acquire it */
|
| + if (pFile->shared->bPending == 0) {
|
| + pFile->shared->bPending = TRUE;
|
| + pFile->local.bPending = TRUE;
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + /* Want a reserved lock? */
|
| + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
|
| + if (pFile->shared->bReserved == 0) {
|
| + pFile->shared->bReserved = TRUE;
|
| + pFile->local.bReserved = TRUE;
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + winceMutexRelease(pFile->hMutex);
|
| + return bReturn;
|
| +}
|
| +
|
| +/*
|
| +** An implementation of the UnlockFile API of windows for wince
|
| +*/
|
| +static BOOL winceUnlockFile(
|
| + HANDLE *phFile,
|
| + DWORD dwFileOffsetLow,
|
| + DWORD dwFileOffsetHigh,
|
| + DWORD nNumberOfBytesToUnlockLow,
|
| + DWORD nNumberOfBytesToUnlockHigh
|
| +){
|
| + winFile *pFile = HANDLE_TO_WINFILE(phFile);
|
| + BOOL bReturn = FALSE;
|
| +
|
| + UNUSED_PARAMETER(dwFileOffsetHigh);
|
| + UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh);
|
| +
|
| + if (!pFile->hMutex) return TRUE;
|
| + winceMutexAcquire(pFile->hMutex);
|
| +
|
| + /* Releasing a reader lock or an exclusive lock */
|
| + if (dwFileOffsetLow == (DWORD)SHARED_FIRST){
|
| + /* Did we have an exclusive lock? */
|
| + if (pFile->local.bExclusive){
|
| + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
|
| + pFile->local.bExclusive = FALSE;
|
| + pFile->shared->bExclusive = FALSE;
|
| + bReturn = TRUE;
|
| + }
|
| +
|
| + /* Did we just have a reader lock? */
|
| + else if (pFile->local.nReaders){
|
| + assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE || nNumberOfBytesToUnlockLow == 1);
|
| + pFile->local.nReaders --;
|
| + if (pFile->local.nReaders == 0)
|
| + {
|
| + pFile->shared->nReaders --;
|
| + }
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + /* Releasing a pending lock */
|
| + else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
|
| + if (pFile->local.bPending){
|
| + pFile->local.bPending = FALSE;
|
| + pFile->shared->bPending = FALSE;
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| + /* Releasing a reserved lock */
|
| + else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
|
| + if (pFile->local.bReserved) {
|
| + pFile->local.bReserved = FALSE;
|
| + pFile->shared->bReserved = FALSE;
|
| + bReturn = TRUE;
|
| + }
|
| + }
|
| +
|
| + winceMutexRelease(pFile->hMutex);
|
| + return bReturn;
|
| +}
|
| +
|
| +/*
|
| +** An implementation of the LockFileEx() API of windows for wince
|
| +*/
|
| +static BOOL winceLockFileEx(
|
| + HANDLE *phFile,
|
| + DWORD dwFlags,
|
| + DWORD dwReserved,
|
| + DWORD nNumberOfBytesToLockLow,
|
| + DWORD nNumberOfBytesToLockHigh,
|
| + LPOVERLAPPED lpOverlapped
|
| +){
|
| + UNUSED_PARAMETER(dwReserved);
|
| + UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
|
| +
|
| + /* If the caller wants a shared read lock, forward this call
|
| + ** to winceLockFile */
|
| + if (lpOverlapped->Offset == (DWORD)SHARED_FIRST &&
|
| + dwFlags == 1 &&
|
| + nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
|
| + return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
|
| + }
|
| + return FALSE;
|
| +}
|
| +/*
|
| +** End of the special code for wince
|
| +*****************************************************************************/
|
| +#endif /* SQLITE_OS_WINCE */
|
| +
|
| +/*****************************************************************************
|
| +** The next group of routines implement the I/O methods specified
|
| +** by the sqlite3_io_methods object.
|
| +******************************************************************************/
|
| +
|
| +/*
|
| +** Some microsoft compilers lack this definition.
|
| +*/
|
| +#ifndef INVALID_SET_FILE_POINTER
|
| +# define INVALID_SET_FILE_POINTER ((DWORD)-1)
|
| +#endif
|
| +
|
| +/*
|
| +** Move the current position of the file handle passed as the first
|
| +** argument to offset iOffset within the file. If successful, return 0.
|
| +** Otherwise, set pFile->lastErrno and return non-zero.
|
| +*/
|
| +static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
|
| + LONG upperBits; /* Most sig. 32 bits of new offset */
|
| + LONG lowerBits; /* Least sig. 32 bits of new offset */
|
| + DWORD dwRet; /* Value returned by SetFilePointer() */
|
| +
|
| + upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
|
| + lowerBits = (LONG)(iOffset & 0xffffffff);
|
| +
|
| + /* API oddity: If successful, SetFilePointer() returns a dword
|
| + ** containing the lower 32-bits of the new file-offset. Or, if it fails,
|
| + ** it returns INVALID_SET_FILE_POINTER. However according to MSDN,
|
| + ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
|
| + ** whether an error has actually occured, it is also necessary to call
|
| + ** GetLastError().
|
| + */
|
| + dwRet = SetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
|
| + if( (dwRet==INVALID_SET_FILE_POINTER && GetLastError()!=NO_ERROR) ){
|
| + pFile->lastErrno = GetLastError();
|
| + return 1;
|
| + }
|
| +
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Close a file.
|
| +**
|
| +** It is reported that an attempt to close a handle might sometimes
|
| +** fail. This is a very unreasonable result, but windows is notorious
|
| +** for being unreasonable so I do not doubt that it might happen. If
|
| +** the close fails, we pause for 100 milliseconds and try again. As
|
| +** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
|
| +** giving up and returning an error.
|
| +*/
|
| +#define MX_CLOSE_ATTEMPT 3
|
| +static int winClose(sqlite3_file *id){
|
| + int rc, cnt = 0;
|
| + winFile *pFile = (winFile*)id;
|
| +
|
| + assert( id!=0 );
|
| + assert( pFile->pShm==0 );
|
| + OSTRACE(("CLOSE %d\n", pFile->h));
|
| + do{
|
| + rc = CloseHandle(pFile->h);
|
| + /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */
|
| + }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (Sleep(100), 1) );
|
| +#if SQLITE_OS_WINCE
|
| +#define WINCE_DELETION_ATTEMPTS 3
|
| + winceDestroyLock(pFile);
|
| + if( pFile->zDeleteOnClose ){
|
| + int cnt = 0;
|
| + while(
|
| + DeleteFileW(pFile->zDeleteOnClose)==0
|
| + && GetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
|
| + && cnt++ < WINCE_DELETION_ATTEMPTS
|
| + ){
|
| + Sleep(100); /* Wait a little before trying again */
|
| + }
|
| + free(pFile->zDeleteOnClose);
|
| + }
|
| +#endif
|
| + OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
|
| + OpenCounter(-1);
|
| + return rc ? SQLITE_OK : SQLITE_IOERR;
|
| +}
|
| +
|
| +/*
|
| +** Read data from a file into a buffer. Return SQLITE_OK if all
|
| +** bytes were read successfully and SQLITE_IOERR if anything goes
|
| +** wrong.
|
| +*/
|
| +static int winRead(
|
| + sqlite3_file *id, /* File to read from */
|
| + void *pBuf, /* Write content into this buffer */
|
| + int amt, /* Number of bytes to read */
|
| + sqlite3_int64 offset /* Begin reading at this offset */
|
| +){
|
| + winFile *pFile = (winFile*)id; /* file handle */
|
| + DWORD nRead; /* Number of bytes actually read from file */
|
| +
|
| + assert( id!=0 );
|
| + SimulateIOError(return SQLITE_IOERR_READ);
|
| + OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
|
| +
|
| + if( seekWinFile(pFile, offset) ){
|
| + return SQLITE_FULL;
|
| + }
|
| + if( !ReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
|
| + pFile->lastErrno = GetLastError();
|
| + return SQLITE_IOERR_READ;
|
| + }
|
| + if( nRead<(DWORD)amt ){
|
| + /* Unread parts of the buffer must be zero-filled */
|
| + memset(&((char*)pBuf)[nRead], 0, amt-nRead);
|
| + return SQLITE_IOERR_SHORT_READ;
|
| + }
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Write data from a buffer into a file. Return SQLITE_OK on success
|
| +** or some other error code on failure.
|
| +*/
|
| +static int winWrite(
|
| + sqlite3_file *id, /* File to write into */
|
| + const void *pBuf, /* The bytes to be written */
|
| + int amt, /* Number of bytes to write */
|
| + sqlite3_int64 offset /* Offset into the file to begin writing at */
|
| +){
|
| + int rc; /* True if error has occured, else false */
|
| + winFile *pFile = (winFile*)id; /* File handle */
|
| +
|
| + assert( amt>0 );
|
| + assert( pFile );
|
| + SimulateIOError(return SQLITE_IOERR_WRITE);
|
| + SimulateDiskfullError(return SQLITE_FULL);
|
| +
|
| + OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
|
| +
|
| + rc = seekWinFile(pFile, offset);
|
| + if( rc==0 ){
|
| + u8 *aRem = (u8 *)pBuf; /* Data yet to be written */
|
| + int nRem = amt; /* Number of bytes yet to be written */
|
| + DWORD nWrite; /* Bytes written by each WriteFile() call */
|
| +
|
| + while( nRem>0 && WriteFile(pFile->h, aRem, nRem, &nWrite, 0) && nWrite>0 ){
|
| + aRem += nWrite;
|
| + nRem -= nWrite;
|
| + }
|
| + if( nRem>0 ){
|
| + pFile->lastErrno = GetLastError();
|
| + rc = 1;
|
| + }
|
| + }
|
| +
|
| + if( rc ){
|
| + if( pFile->lastErrno==ERROR_HANDLE_DISK_FULL ){
|
| + return SQLITE_FULL;
|
| + }
|
| + return SQLITE_IOERR_WRITE;
|
| + }
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Truncate an open file to a specified size
|
| +*/
|
| +static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
|
| + winFile *pFile = (winFile*)id; /* File handle object */
|
| + int rc = SQLITE_OK; /* Return code for this function */
|
| +
|
| + assert( pFile );
|
| +
|
| + OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
|
| + SimulateIOError(return SQLITE_IOERR_TRUNCATE);
|
| +
|
| + /* If the user has configured a chunk-size for this file, truncate the
|
| + ** file so that it consists of an integer number of chunks (i.e. the
|
| + ** actual file size after the operation may be larger than the requested
|
| + ** size).
|
| + */
|
| + if( pFile->szChunk ){
|
| + nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
|
| + }
|
| +
|
| + /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
|
| + if( seekWinFile(pFile, nByte) ){
|
| + rc = SQLITE_IOERR_TRUNCATE;
|
| + }else if( 0==SetEndOfFile(pFile->h) ){
|
| + pFile->lastErrno = GetLastError();
|
| + rc = SQLITE_IOERR_TRUNCATE;
|
| + }
|
| +
|
| + OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
|
| + return rc;
|
| +}
|
| +
|
| +#ifdef SQLITE_TEST
|
| +/*
|
| +** Count the number of fullsyncs and normal syncs. This is used to test
|
| +** that syncs and fullsyncs are occuring at the right times.
|
| +*/
|
| +int sqlite3_sync_count = 0;
|
| +int sqlite3_fullsync_count = 0;
|
| +#endif
|
| +
|
| +/*
|
| +** Make sure all writes to a particular file are committed to disk.
|
| +*/
|
| +static int winSync(sqlite3_file *id, int flags){
|
| +#if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || defined(SQLITE_DEBUG)
|
| + winFile *pFile = (winFile*)id;
|
| +#else
|
| + UNUSED_PARAMETER(id);
|
| +#endif
|
| +
|
| + assert( pFile );
|
| + /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
|
| + assert((flags&0x0F)==SQLITE_SYNC_NORMAL
|
| + || (flags&0x0F)==SQLITE_SYNC_FULL
|
| + );
|
| +
|
| + OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
|
| +
|
| +#ifndef SQLITE_TEST
|
| + UNUSED_PARAMETER(flags);
|
| +#else
|
| + if( flags & SQLITE_SYNC_FULL ){
|
| + sqlite3_fullsync_count++;
|
| + }
|
| + sqlite3_sync_count++;
|
| +#endif
|
| +
|
| + /* Unix cannot, but some systems may return SQLITE_FULL from here. This
|
| + ** line is to test that doing so does not cause any problems.
|
| + */
|
| + SimulateDiskfullError( return SQLITE_FULL );
|
| + SimulateIOError( return SQLITE_IOERR; );
|
| +
|
| + /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
|
| + ** no-op
|
| + */
|
| +#ifdef SQLITE_NO_SYNC
|
| + return SQLITE_OK;
|
| +#else
|
| + if( FlushFileBuffers(pFile->h) ){
|
| + return SQLITE_OK;
|
| + }else{
|
| + pFile->lastErrno = GetLastError();
|
| + return SQLITE_IOERR;
|
| + }
|
| +#endif
|
| +}
|
| +
|
| +/*
|
| +** Determine the current size of a file in bytes
|
| +*/
|
| +static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
|
| + DWORD upperBits;
|
| + DWORD lowerBits;
|
| + winFile *pFile = (winFile*)id;
|
| + DWORD error;
|
| +
|
| + assert( id!=0 );
|
| + SimulateIOError(return SQLITE_IOERR_FSTAT);
|
| + lowerBits = GetFileSize(pFile->h, &upperBits);
|
| + if( (lowerBits == INVALID_FILE_SIZE)
|
| + && ((error = GetLastError()) != NO_ERROR) )
|
| + {
|
| + pFile->lastErrno = error;
|
| + return SQLITE_IOERR_FSTAT;
|
| + }
|
| + *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
|
| +*/
|
| +#ifndef LOCKFILE_FAIL_IMMEDIATELY
|
| +# define LOCKFILE_FAIL_IMMEDIATELY 1
|
| +#endif
|
| +
|
| +/*
|
| +** Acquire a reader lock.
|
| +** Different API routines are called depending on whether or not this
|
| +** is Win95 or WinNT.
|
| +*/
|
| +static int getReadLock(winFile *pFile){
|
| + int res;
|
| + if( isNT() ){
|
| + OVERLAPPED ovlp;
|
| + ovlp.Offset = SHARED_FIRST;
|
| + ovlp.OffsetHigh = 0;
|
| + ovlp.hEvent = 0;
|
| + res = LockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
|
| + 0, SHARED_SIZE, 0, &ovlp);
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + int lk;
|
| + sqlite3_randomness(sizeof(lk), &lk);
|
| + pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
|
| + res = LockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
|
| +#endif
|
| + }
|
| + if( res == 0 ){
|
| + pFile->lastErrno = GetLastError();
|
| + }
|
| + return res;
|
| +}
|
| +
|
| +/*
|
| +** Undo a readlock
|
| +*/
|
| +static int unlockReadLock(winFile *pFile){
|
| + int res;
|
| + if( isNT() ){
|
| + res = UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + res = UnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
|
| +#endif
|
| + }
|
| + if( res == 0 ){
|
| + pFile->lastErrno = GetLastError();
|
| + }
|
| + return res;
|
| +}
|
| +
|
| +/*
|
| +** Lock the file with the lock specified by parameter locktype - one
|
| +** of the following:
|
| +**
|
| +** (1) SHARED_LOCK
|
| +** (2) RESERVED_LOCK
|
| +** (3) PENDING_LOCK
|
| +** (4) EXCLUSIVE_LOCK
|
| +**
|
| +** Sometimes when requesting one lock state, additional lock states
|
| +** are inserted in between. The locking might fail on one of the later
|
| +** transitions leaving the lock state different from what it started but
|
| +** still short of its goal. The following chart shows the allowed
|
| +** transitions and the inserted intermediate states:
|
| +**
|
| +** UNLOCKED -> SHARED
|
| +** SHARED -> RESERVED
|
| +** SHARED -> (PENDING) -> EXCLUSIVE
|
| +** RESERVED -> (PENDING) -> EXCLUSIVE
|
| +** PENDING -> EXCLUSIVE
|
| +**
|
| +** This routine will only increase a lock. The winUnlock() routine
|
| +** erases all locks at once and returns us immediately to locking level 0.
|
| +** It is not possible to lower the locking level one step at a time. You
|
| +** must go straight to locking level 0.
|
| +*/
|
| +static int winLock(sqlite3_file *id, int locktype){
|
| + int rc = SQLITE_OK; /* Return code from subroutines */
|
| + int res = 1; /* Result of a windows lock call */
|
| + int newLocktype; /* Set pFile->locktype to this value before exiting */
|
| + int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
|
| + winFile *pFile = (winFile*)id;
|
| + DWORD error = NO_ERROR;
|
| +
|
| + assert( id!=0 );
|
| + OSTRACE(("LOCK %d %d was %d(%d)\n",
|
| + pFile->h, locktype, pFile->locktype, pFile->sharedLockByte));
|
| +
|
| + /* If there is already a lock of this type or more restrictive on the
|
| + ** OsFile, do nothing. Don't use the end_lock: exit path, as
|
| + ** sqlite3OsEnterMutex() hasn't been called yet.
|
| + */
|
| + if( pFile->locktype>=locktype ){
|
| + return SQLITE_OK;
|
| + }
|
| +
|
| + /* Make sure the locking sequence is correct
|
| + */
|
| + assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
|
| + assert( locktype!=PENDING_LOCK );
|
| + assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
|
| +
|
| + /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
|
| + ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
|
| + ** the PENDING_LOCK byte is temporary.
|
| + */
|
| + newLocktype = pFile->locktype;
|
| + if( (pFile->locktype==NO_LOCK)
|
| + || ( (locktype==EXCLUSIVE_LOCK)
|
| + && (pFile->locktype==RESERVED_LOCK))
|
| + ){
|
| + int cnt = 3;
|
| + while( cnt-->0 && (res = LockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
|
| + /* Try 3 times to get the pending lock. The pending lock might be
|
| + ** held by another reader process who will release it momentarily.
|
| + */
|
| + OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
|
| + Sleep(1);
|
| + }
|
| + gotPendingLock = res;
|
| + if( !res ){
|
| + error = GetLastError();
|
| + }
|
| + }
|
| +
|
| + /* Acquire a shared lock
|
| + */
|
| + if( locktype==SHARED_LOCK && res ){
|
| + assert( pFile->locktype==NO_LOCK );
|
| + res = getReadLock(pFile);
|
| + if( res ){
|
| + newLocktype = SHARED_LOCK;
|
| + }else{
|
| + error = GetLastError();
|
| + }
|
| + }
|
| +
|
| + /* Acquire a RESERVED lock
|
| + */
|
| + if( locktype==RESERVED_LOCK && res ){
|
| + assert( pFile->locktype==SHARED_LOCK );
|
| + res = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
|
| + if( res ){
|
| + newLocktype = RESERVED_LOCK;
|
| + }else{
|
| + error = GetLastError();
|
| + }
|
| + }
|
| +
|
| + /* Acquire a PENDING lock
|
| + */
|
| + if( locktype==EXCLUSIVE_LOCK && res ){
|
| + newLocktype = PENDING_LOCK;
|
| + gotPendingLock = 0;
|
| + }
|
| +
|
| + /* Acquire an EXCLUSIVE lock
|
| + */
|
| + if( locktype==EXCLUSIVE_LOCK && res ){
|
| + assert( pFile->locktype>=SHARED_LOCK );
|
| + res = unlockReadLock(pFile);
|
| + OSTRACE(("unreadlock = %d\n", res));
|
| + res = LockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
|
| + if( res ){
|
| + newLocktype = EXCLUSIVE_LOCK;
|
| + }else{
|
| + error = GetLastError();
|
| + OSTRACE(("error-code = %d\n", error));
|
| + getReadLock(pFile);
|
| + }
|
| + }
|
| +
|
| + /* If we are holding a PENDING lock that ought to be released, then
|
| + ** release it now.
|
| + */
|
| + if( gotPendingLock && locktype==SHARED_LOCK ){
|
| + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
|
| + }
|
| +
|
| + /* Update the state of the lock has held in the file descriptor then
|
| + ** return the appropriate result code.
|
| + */
|
| + if( res ){
|
| + rc = SQLITE_OK;
|
| + }else{
|
| + OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
|
| + locktype, newLocktype));
|
| + pFile->lastErrno = error;
|
| + rc = SQLITE_BUSY;
|
| + }
|
| + pFile->locktype = (u8)newLocktype;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** This routine checks if there is a RESERVED lock held on the specified
|
| +** file by this or any other process. If such a lock is held, return
|
| +** non-zero, otherwise zero.
|
| +*/
|
| +static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
|
| + int rc;
|
| + winFile *pFile = (winFile*)id;
|
| +
|
| + SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
|
| +
|
| + assert( id!=0 );
|
| + if( pFile->locktype>=RESERVED_LOCK ){
|
| + rc = 1;
|
| + OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc));
|
| + }else{
|
| + rc = LockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
|
| + if( rc ){
|
| + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
|
| + }
|
| + rc = !rc;
|
| + OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc));
|
| + }
|
| + *pResOut = rc;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Lower the locking level on file descriptor id to locktype. locktype
|
| +** must be either NO_LOCK or SHARED_LOCK.
|
| +**
|
| +** If the locking level of the file descriptor is already at or below
|
| +** the requested locking level, this routine is a no-op.
|
| +**
|
| +** It is not possible for this routine to fail if the second argument
|
| +** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
|
| +** might return SQLITE_IOERR;
|
| +*/
|
| +static int winUnlock(sqlite3_file *id, int locktype){
|
| + int type;
|
| + winFile *pFile = (winFile*)id;
|
| + int rc = SQLITE_OK;
|
| + assert( pFile!=0 );
|
| + assert( locktype<=SHARED_LOCK );
|
| + OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
|
| + pFile->locktype, pFile->sharedLockByte));
|
| + type = pFile->locktype;
|
| + if( type>=EXCLUSIVE_LOCK ){
|
| + UnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
|
| + if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
|
| + /* This should never happen. We should always be able to
|
| + ** reacquire the read lock */
|
| + rc = SQLITE_IOERR_UNLOCK;
|
| + }
|
| + }
|
| + if( type>=RESERVED_LOCK ){
|
| + UnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
|
| + }
|
| + if( locktype==NO_LOCK && type>=SHARED_LOCK ){
|
| + unlockReadLock(pFile);
|
| + }
|
| + if( type>=PENDING_LOCK ){
|
| + UnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
|
| + }
|
| + pFile->locktype = (u8)locktype;
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Control and query of the open file handle.
|
| +*/
|
| +static int winFileControl(sqlite3_file *id, int op, void *pArg){
|
| + switch( op ){
|
| + case SQLITE_FCNTL_LOCKSTATE: {
|
| + *(int*)pArg = ((winFile*)id)->locktype;
|
| + return SQLITE_OK;
|
| + }
|
| + case SQLITE_LAST_ERRNO: {
|
| + *(int*)pArg = (int)((winFile*)id)->lastErrno;
|
| + return SQLITE_OK;
|
| + }
|
| + case SQLITE_FCNTL_CHUNK_SIZE: {
|
| + ((winFile*)id)->szChunk = *(int *)pArg;
|
| + return SQLITE_OK;
|
| + }
|
| + case SQLITE_FCNTL_SIZE_HINT: {
|
| + sqlite3_int64 sz = *(sqlite3_int64*)pArg;
|
| + SimulateIOErrorBenign(1);
|
| + winTruncate(id, sz);
|
| + SimulateIOErrorBenign(0);
|
| + return SQLITE_OK;
|
| + }
|
| + case SQLITE_FCNTL_SYNC_OMITTED: {
|
| + return SQLITE_OK;
|
| + }
|
| + }
|
| + return SQLITE_NOTFOUND;
|
| +}
|
| +
|
| +/*
|
| +** Return the sector size in bytes of the underlying block device for
|
| +** the specified file. This is almost always 512 bytes, but may be
|
| +** larger for some devices.
|
| +**
|
| +** SQLite code assumes this function cannot fail. It also assumes that
|
| +** if two files are created in the same file-system directory (i.e.
|
| +** a database and its journal file) that the sector size will be the
|
| +** same for both.
|
| +*/
|
| +static int winSectorSize(sqlite3_file *id){
|
| + assert( id!=0 );
|
| + return (int)(((winFile*)id)->sectorSize);
|
| +}
|
| +
|
| +/*
|
| +** Return a vector of device characteristics.
|
| +*/
|
| +static int winDeviceCharacteristics(sqlite3_file *id){
|
| + UNUSED_PARAMETER(id);
|
| + return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
|
| +}
|
| +
|
| +#ifndef SQLITE_OMIT_WAL
|
| +
|
| +/*
|
| +** Windows will only let you create file view mappings
|
| +** on allocation size granularity boundaries.
|
| +** During sqlite3_os_init() we do a GetSystemInfo()
|
| +** to get the granularity size.
|
| +*/
|
| +SYSTEM_INFO winSysInfo;
|
| +
|
| +/*
|
| +** Helper functions to obtain and relinquish the global mutex. The
|
| +** global mutex is used to protect the winLockInfo objects used by
|
| +** this file, all of which may be shared by multiple threads.
|
| +**
|
| +** Function winShmMutexHeld() is used to assert() that the global mutex
|
| +** is held when required. This function is only used as part of assert()
|
| +** statements. e.g.
|
| +**
|
| +** winShmEnterMutex()
|
| +** assert( winShmMutexHeld() );
|
| +** winShmLeaveMutex()
|
| +*/
|
| +static void winShmEnterMutex(void){
|
| + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
|
| +}
|
| +static void winShmLeaveMutex(void){
|
| + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
|
| +}
|
| +#ifdef SQLITE_DEBUG
|
| +static int winShmMutexHeld(void) {
|
| + return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
|
| +}
|
| +#endif
|
| +
|
| +/*
|
| +** Object used to represent a single file opened and mmapped to provide
|
| +** shared memory. When multiple threads all reference the same
|
| +** log-summary, each thread has its own winFile object, but they all
|
| +** point to a single instance of this object. In other words, each
|
| +** log-summary is opened only once per process.
|
| +**
|
| +** winShmMutexHeld() must be true when creating or destroying
|
| +** this object or while reading or writing the following fields:
|
| +**
|
| +** nRef
|
| +** pNext
|
| +**
|
| +** The following fields are read-only after the object is created:
|
| +**
|
| +** fid
|
| +** zFilename
|
| +**
|
| +** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
|
| +** winShmMutexHeld() is true when reading or writing any other field
|
| +** in this structure.
|
| +**
|
| +*/
|
| +struct winShmNode {
|
| + sqlite3_mutex *mutex; /* Mutex to access this object */
|
| + char *zFilename; /* Name of the file */
|
| + winFile hFile; /* File handle from winOpen */
|
| +
|
| + int szRegion; /* Size of shared-memory regions */
|
| + int nRegion; /* Size of array apRegion */
|
| + struct ShmRegion {
|
| + HANDLE hMap; /* File handle from CreateFileMapping */
|
| + void *pMap;
|
| + } *aRegion;
|
| + DWORD lastErrno; /* The Windows errno from the last I/O error */
|
| +
|
| + int nRef; /* Number of winShm objects pointing to this */
|
| + winShm *pFirst; /* All winShm objects pointing to this */
|
| + winShmNode *pNext; /* Next in list of all winShmNode objects */
|
| +#ifdef SQLITE_DEBUG
|
| + u8 nextShmId; /* Next available winShm.id value */
|
| +#endif
|
| +};
|
| +
|
| +/*
|
| +** A global array of all winShmNode objects.
|
| +**
|
| +** The winShmMutexHeld() must be true while reading or writing this list.
|
| +*/
|
| +static winShmNode *winShmNodeList = 0;
|
| +
|
| +/*
|
| +** Structure used internally by this VFS to record the state of an
|
| +** open shared memory connection.
|
| +**
|
| +** The following fields are initialized when this object is created and
|
| +** are read-only thereafter:
|
| +**
|
| +** winShm.pShmNode
|
| +** winShm.id
|
| +**
|
| +** All other fields are read/write. The winShm.pShmNode->mutex must be held
|
| +** while accessing any read/write fields.
|
| +*/
|
| +struct winShm {
|
| + winShmNode *pShmNode; /* The underlying winShmNode object */
|
| + winShm *pNext; /* Next winShm with the same winShmNode */
|
| + u8 hasMutex; /* True if holding the winShmNode mutex */
|
| + u16 sharedMask; /* Mask of shared locks held */
|
| + u16 exclMask; /* Mask of exclusive locks held */
|
| +#ifdef SQLITE_DEBUG
|
| + u8 id; /* Id of this connection with its winShmNode */
|
| +#endif
|
| +};
|
| +
|
| +/*
|
| +** Constants used for locking
|
| +*/
|
| +#define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
|
| +#define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
|
| +
|
| +/*
|
| +** Apply advisory locks for all n bytes beginning at ofst.
|
| +*/
|
| +#define _SHM_UNLCK 1
|
| +#define _SHM_RDLCK 2
|
| +#define _SHM_WRLCK 3
|
| +static int winShmSystemLock(
|
| + winShmNode *pFile, /* Apply locks to this open shared-memory segment */
|
| + int lockType, /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */
|
| + int ofst, /* Offset to first byte to be locked/unlocked */
|
| + int nByte /* Number of bytes to lock or unlock */
|
| +){
|
| + OVERLAPPED ovlp;
|
| + DWORD dwFlags;
|
| + int rc = 0; /* Result code form Lock/UnlockFileEx() */
|
| +
|
| + /* Access to the winShmNode object is serialized by the caller */
|
| + assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
|
| +
|
| + /* Initialize the locking parameters */
|
| + dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
|
| + if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
|
| +
|
| + memset(&ovlp, 0, sizeof(OVERLAPPED));
|
| + ovlp.Offset = ofst;
|
| +
|
| + /* Release/Acquire the system-level lock */
|
| + if( lockType==_SHM_UNLCK ){
|
| + rc = UnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
|
| + }else{
|
| + rc = LockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
|
| + }
|
| +
|
| + if( rc!= 0 ){
|
| + rc = SQLITE_OK;
|
| + }else{
|
| + pFile->lastErrno = GetLastError();
|
| + rc = SQLITE_BUSY;
|
| + }
|
| +
|
| + OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
|
| + pFile->hFile.h,
|
| + rc==SQLITE_OK ? "ok" : "failed",
|
| + lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
|
| + pFile->lastErrno));
|
| +
|
| + return rc;
|
| +}
|
| +
|
| +/* Forward references to VFS methods */
|
| +static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*);
|
| +static int winDelete(sqlite3_vfs *,const char*,int);
|
| +
|
| +/*
|
| +** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
|
| +**
|
| +** This is not a VFS shared-memory method; it is a utility function called
|
| +** by VFS shared-memory methods.
|
| +*/
|
| +static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
|
| + winShmNode **pp;
|
| + winShmNode *p;
|
| + BOOL bRc;
|
| + assert( winShmMutexHeld() );
|
| + pp = &winShmNodeList;
|
| + while( (p = *pp)!=0 ){
|
| + if( p->nRef==0 ){
|
| + int i;
|
| + if( p->mutex ) sqlite3_mutex_free(p->mutex);
|
| + for(i=0; i<p->nRegion; i++){
|
| + bRc = UnmapViewOfFile(p->aRegion[i].pMap);
|
| + OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
|
| + (int)GetCurrentProcessId(), i,
|
| + bRc ? "ok" : "failed"));
|
| + bRc = CloseHandle(p->aRegion[i].hMap);
|
| + OSTRACE(("SHM-PURGE pid-%d close region=%d %s\n",
|
| + (int)GetCurrentProcessId(), i,
|
| + bRc ? "ok" : "failed"));
|
| + }
|
| + if( p->hFile.h != INVALID_HANDLE_VALUE ){
|
| + SimulateIOErrorBenign(1);
|
| + winClose((sqlite3_file *)&p->hFile);
|
| + SimulateIOErrorBenign(0);
|
| + }
|
| + if( deleteFlag ){
|
| + SimulateIOErrorBenign(1);
|
| + winDelete(pVfs, p->zFilename, 0);
|
| + SimulateIOErrorBenign(0);
|
| + }
|
| + *pp = p->pNext;
|
| + sqlite3_free(p->aRegion);
|
| + sqlite3_free(p);
|
| + }else{
|
| + pp = &p->pNext;
|
| + }
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Open the shared-memory area associated with database file pDbFd.
|
| +**
|
| +** When opening a new shared-memory file, if no other instances of that
|
| +** file are currently open, in this process or in other processes, then
|
| +** the file must be truncated to zero length or have its header cleared.
|
| +*/
|
| +static int winOpenSharedMemory(winFile *pDbFd){
|
| + struct winShm *p; /* The connection to be opened */
|
| + struct winShmNode *pShmNode = 0; /* The underlying mmapped file */
|
| + int rc; /* Result code */
|
| + struct winShmNode *pNew; /* Newly allocated winShmNode */
|
| + int nName; /* Size of zName in bytes */
|
| +
|
| + assert( pDbFd->pShm==0 ); /* Not previously opened */
|
| +
|
| + /* Allocate space for the new sqlite3_shm object. Also speculatively
|
| + ** allocate space for a new winShmNode and filename.
|
| + */
|
| + p = sqlite3_malloc( sizeof(*p) );
|
| + if( p==0 ) return SQLITE_NOMEM;
|
| + memset(p, 0, sizeof(*p));
|
| + nName = sqlite3Strlen30(pDbFd->zPath);
|
| + pNew = sqlite3_malloc( sizeof(*pShmNode) + nName + 15 );
|
| + if( pNew==0 ){
|
| + sqlite3_free(p);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memset(pNew, 0, sizeof(*pNew));
|
| + pNew->zFilename = (char*)&pNew[1];
|
| + sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
|
| +
|
| + /* Look to see if there is an existing winShmNode that can be used.
|
| + ** If no matching winShmNode currently exists, create a new one.
|
| + */
|
| + winShmEnterMutex();
|
| + for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
|
| + /* TBD need to come up with better match here. Perhaps
|
| + ** use FILE_ID_BOTH_DIR_INFO Structure.
|
| + */
|
| + if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
|
| + }
|
| + if( pShmNode ){
|
| + sqlite3_free(pNew);
|
| + }else{
|
| + pShmNode = pNew;
|
| + pNew = 0;
|
| + ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
|
| + pShmNode->pNext = winShmNodeList;
|
| + winShmNodeList = pShmNode;
|
| +
|
| + pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
|
| + if( pShmNode->mutex==0 ){
|
| + rc = SQLITE_NOMEM;
|
| + goto shm_open_err;
|
| + }
|
| +
|
| + rc = winOpen(pDbFd->pVfs,
|
| + pShmNode->zFilename, /* Name of the file (UTF-8) */
|
| + (sqlite3_file*)&pShmNode->hFile, /* File handle here */
|
| + SQLITE_OPEN_WAL | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, /* Mode flags */
|
| + 0);
|
| + if( SQLITE_OK!=rc ){
|
| + rc = SQLITE_CANTOPEN_BKPT;
|
| + goto shm_open_err;
|
| + }
|
| +
|
| + /* Check to see if another process is holding the dead-man switch.
|
| + ** If not, truncate the file to zero length.
|
| + */
|
| + if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
|
| + rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0);
|
| + if( rc!=SQLITE_OK ){
|
| + rc = SQLITE_IOERR_SHMOPEN;
|
| + }
|
| + }
|
| + if( rc==SQLITE_OK ){
|
| + winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
|
| + rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
|
| + }
|
| + if( rc ) goto shm_open_err;
|
| + }
|
| +
|
| + /* Make the new connection a child of the winShmNode */
|
| + p->pShmNode = pShmNode;
|
| +#ifdef SQLITE_DEBUG
|
| + p->id = pShmNode->nextShmId++;
|
| +#endif
|
| + pShmNode->nRef++;
|
| + pDbFd->pShm = p;
|
| + winShmLeaveMutex();
|
| +
|
| + /* The reference count on pShmNode has already been incremented under
|
| + ** the cover of the winShmEnterMutex() mutex and the pointer from the
|
| + ** new (struct winShm) object to the pShmNode has been set. All that is
|
| + ** left to do is to link the new object into the linked list starting
|
| + ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
|
| + ** mutex.
|
| + */
|
| + sqlite3_mutex_enter(pShmNode->mutex);
|
| + p->pNext = pShmNode->pFirst;
|
| + pShmNode->pFirst = p;
|
| + sqlite3_mutex_leave(pShmNode->mutex);
|
| + return SQLITE_OK;
|
| +
|
| + /* Jump here on any error */
|
| +shm_open_err:
|
| + winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
|
| + winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */
|
| + sqlite3_free(p);
|
| + sqlite3_free(pNew);
|
| + winShmLeaveMutex();
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Close a connection to shared-memory. Delete the underlying
|
| +** storage if deleteFlag is true.
|
| +*/
|
| +static int winShmUnmap(
|
| + sqlite3_file *fd, /* Database holding shared memory */
|
| + int deleteFlag /* Delete after closing if true */
|
| +){
|
| + winFile *pDbFd; /* Database holding shared-memory */
|
| + winShm *p; /* The connection to be closed */
|
| + winShmNode *pShmNode; /* The underlying shared-memory file */
|
| + winShm **pp; /* For looping over sibling connections */
|
| +
|
| + pDbFd = (winFile*)fd;
|
| + p = pDbFd->pShm;
|
| + if( p==0 ) return SQLITE_OK;
|
| + pShmNode = p->pShmNode;
|
| +
|
| + /* Remove connection p from the set of connections associated
|
| + ** with pShmNode */
|
| + sqlite3_mutex_enter(pShmNode->mutex);
|
| + for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
|
| + *pp = p->pNext;
|
| +
|
| + /* Free the connection p */
|
| + sqlite3_free(p);
|
| + pDbFd->pShm = 0;
|
| + sqlite3_mutex_leave(pShmNode->mutex);
|
| +
|
| + /* If pShmNode->nRef has reached 0, then close the underlying
|
| + ** shared-memory file, too */
|
| + winShmEnterMutex();
|
| + assert( pShmNode->nRef>0 );
|
| + pShmNode->nRef--;
|
| + if( pShmNode->nRef==0 ){
|
| + winShmPurge(pDbFd->pVfs, deleteFlag);
|
| + }
|
| + winShmLeaveMutex();
|
| +
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Change the lock state for a shared-memory segment.
|
| +*/
|
| +static int winShmLock(
|
| + sqlite3_file *fd, /* Database file holding the shared memory */
|
| + int ofst, /* First lock to acquire or release */
|
| + int n, /* Number of locks to acquire or release */
|
| + int flags /* What to do with the lock */
|
| +){
|
| + winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */
|
| + winShm *p = pDbFd->pShm; /* The shared memory being locked */
|
| + winShm *pX; /* For looping over all siblings */
|
| + winShmNode *pShmNode = p->pShmNode;
|
| + int rc = SQLITE_OK; /* Result code */
|
| + u16 mask; /* Mask of locks to take or release */
|
| +
|
| + assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
|
| + assert( n>=1 );
|
| + assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
|
| + || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
|
| + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
|
| + || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
|
| + assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
|
| +
|
| + mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
|
| + assert( n>1 || mask==(1<<ofst) );
|
| + sqlite3_mutex_enter(pShmNode->mutex);
|
| + if( flags & SQLITE_SHM_UNLOCK ){
|
| + u16 allMask = 0; /* Mask of locks held by siblings */
|
| +
|
| + /* See if any siblings hold this same lock */
|
| + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
|
| + if( pX==p ) continue;
|
| + assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
|
| + allMask |= pX->sharedMask;
|
| + }
|
| +
|
| + /* Unlock the system-level locks */
|
| + if( (mask & allMask)==0 ){
|
| + rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
|
| + }else{
|
| + rc = SQLITE_OK;
|
| + }
|
| +
|
| + /* Undo the local locks */
|
| + if( rc==SQLITE_OK ){
|
| + p->exclMask &= ~mask;
|
| + p->sharedMask &= ~mask;
|
| + }
|
| + }else if( flags & SQLITE_SHM_SHARED ){
|
| + u16 allShared = 0; /* Union of locks held by connections other than "p" */
|
| +
|
| + /* Find out which shared locks are already held by sibling connections.
|
| + ** If any sibling already holds an exclusive lock, go ahead and return
|
| + ** SQLITE_BUSY.
|
| + */
|
| + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
|
| + if( (pX->exclMask & mask)!=0 ){
|
| + rc = SQLITE_BUSY;
|
| + break;
|
| + }
|
| + allShared |= pX->sharedMask;
|
| + }
|
| +
|
| + /* Get shared locks at the system level, if necessary */
|
| + if( rc==SQLITE_OK ){
|
| + if( (allShared & mask)==0 ){
|
| + rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
|
| + }else{
|
| + rc = SQLITE_OK;
|
| + }
|
| + }
|
| +
|
| + /* Get the local shared locks */
|
| + if( rc==SQLITE_OK ){
|
| + p->sharedMask |= mask;
|
| + }
|
| + }else{
|
| + /* Make sure no sibling connections hold locks that will block this
|
| + ** lock. If any do, return SQLITE_BUSY right away.
|
| + */
|
| + for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
|
| + if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
|
| + rc = SQLITE_BUSY;
|
| + break;
|
| + }
|
| + }
|
| +
|
| + /* Get the exclusive locks at the system level. Then if successful
|
| + ** also mark the local connection as being locked.
|
| + */
|
| + if( rc==SQLITE_OK ){
|
| + rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
|
| + if( rc==SQLITE_OK ){
|
| + assert( (p->sharedMask & mask)==0 );
|
| + p->exclMask |= mask;
|
| + }
|
| + }
|
| + }
|
| + sqlite3_mutex_leave(pShmNode->mutex);
|
| + OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
|
| + p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
|
| + rc ? "failed" : "ok"));
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Implement a memory barrier or memory fence on shared memory.
|
| +**
|
| +** All loads and stores begun before the barrier must complete before
|
| +** any load or store begun after the barrier.
|
| +*/
|
| +static void winShmBarrier(
|
| + sqlite3_file *fd /* Database holding the shared memory */
|
| +){
|
| + UNUSED_PARAMETER(fd);
|
| + /* MemoryBarrier(); // does not work -- do not know why not */
|
| + winShmEnterMutex();
|
| + winShmLeaveMutex();
|
| +}
|
| +
|
| +/*
|
| +** This function is called to obtain a pointer to region iRegion of the
|
| +** shared-memory associated with the database file fd. Shared-memory regions
|
| +** are numbered starting from zero. Each shared-memory region is szRegion
|
| +** bytes in size.
|
| +**
|
| +** If an error occurs, an error code is returned and *pp is set to NULL.
|
| +**
|
| +** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
|
| +** region has not been allocated (by any client, including one running in a
|
| +** separate process), then *pp is set to NULL and SQLITE_OK returned. If
|
| +** isWrite is non-zero and the requested shared-memory region has not yet
|
| +** been allocated, it is allocated by this function.
|
| +**
|
| +** If the shared-memory region has already been allocated or is allocated by
|
| +** this call as described above, then it is mapped into this processes
|
| +** address space (if it is not already), *pp is set to point to the mapped
|
| +** memory and SQLITE_OK returned.
|
| +*/
|
| +static int winShmMap(
|
| + sqlite3_file *fd, /* Handle open on database file */
|
| + int iRegion, /* Region to retrieve */
|
| + int szRegion, /* Size of regions */
|
| + int isWrite, /* True to extend file if necessary */
|
| + void volatile **pp /* OUT: Mapped memory */
|
| +){
|
| + winFile *pDbFd = (winFile*)fd;
|
| + winShm *p = pDbFd->pShm;
|
| + winShmNode *pShmNode;
|
| + int rc = SQLITE_OK;
|
| +
|
| + if( !p ){
|
| + rc = winOpenSharedMemory(pDbFd);
|
| + if( rc!=SQLITE_OK ) return rc;
|
| + p = pDbFd->pShm;
|
| + }
|
| + pShmNode = p->pShmNode;
|
| +
|
| + sqlite3_mutex_enter(pShmNode->mutex);
|
| + assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
|
| +
|
| + if( pShmNode->nRegion<=iRegion ){
|
| + struct ShmRegion *apNew; /* New aRegion[] array */
|
| + int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
|
| + sqlite3_int64 sz; /* Current size of wal-index file */
|
| +
|
| + pShmNode->szRegion = szRegion;
|
| +
|
| + /* The requested region is not mapped into this processes address space.
|
| + ** Check to see if it has been allocated (i.e. if the wal-index file is
|
| + ** large enough to contain the requested region).
|
| + */
|
| + rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
|
| + if( rc!=SQLITE_OK ){
|
| + rc = SQLITE_IOERR_SHMSIZE;
|
| + goto shmpage_out;
|
| + }
|
| +
|
| + if( sz<nByte ){
|
| + /* The requested memory region does not exist. If isWrite is set to
|
| + ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
|
| + **
|
| + ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
|
| + ** the requested memory region.
|
| + */
|
| + if( !isWrite ) goto shmpage_out;
|
| + rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
|
| + if( rc!=SQLITE_OK ){
|
| + rc = SQLITE_IOERR_SHMSIZE;
|
| + goto shmpage_out;
|
| + }
|
| + }
|
| +
|
| + /* Map the requested memory region into this processes address space. */
|
| + apNew = (struct ShmRegion *)sqlite3_realloc(
|
| + pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
|
| + );
|
| + if( !apNew ){
|
| + rc = SQLITE_IOERR_NOMEM;
|
| + goto shmpage_out;
|
| + }
|
| + pShmNode->aRegion = apNew;
|
| +
|
| + while( pShmNode->nRegion<=iRegion ){
|
| + HANDLE hMap; /* file-mapping handle */
|
| + void *pMap = 0; /* Mapped memory region */
|
| +
|
| + hMap = CreateFileMapping(pShmNode->hFile.h,
|
| + NULL, PAGE_READWRITE, 0, nByte, NULL
|
| + );
|
| + OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n",
|
| + (int)GetCurrentProcessId(), pShmNode->nRegion, nByte,
|
| + hMap ? "ok" : "failed"));
|
| + if( hMap ){
|
| + int iOffset = pShmNode->nRegion*szRegion;
|
| + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
|
| + pMap = MapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ,
|
| + 0, iOffset - iOffsetShift, szRegion + iOffsetShift
|
| + );
|
| + OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n",
|
| + (int)GetCurrentProcessId(), pShmNode->nRegion, iOffset, szRegion,
|
| + pMap ? "ok" : "failed"));
|
| + }
|
| + if( !pMap ){
|
| + pShmNode->lastErrno = GetLastError();
|
| + rc = SQLITE_IOERR;
|
| + if( hMap ) CloseHandle(hMap);
|
| + goto shmpage_out;
|
| + }
|
| +
|
| + pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
|
| + pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
|
| + pShmNode->nRegion++;
|
| + }
|
| + }
|
| +
|
| +shmpage_out:
|
| + if( pShmNode->nRegion>iRegion ){
|
| + int iOffset = iRegion*szRegion;
|
| + int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
|
| + char *p = (char *)pShmNode->aRegion[iRegion].pMap;
|
| + *pp = (void *)&p[iOffsetShift];
|
| + }else{
|
| + *pp = 0;
|
| + }
|
| + sqlite3_mutex_leave(pShmNode->mutex);
|
| + return rc;
|
| +}
|
| +
|
| +#else
|
| +# define winShmMap 0
|
| +# define winShmLock 0
|
| +# define winShmBarrier 0
|
| +# define winShmUnmap 0
|
| +#endif /* #ifndef SQLITE_OMIT_WAL */
|
| +
|
| +/*
|
| +** Here ends the implementation of all sqlite3_file methods.
|
| +**
|
| +********************** End sqlite3_file Methods *******************************
|
| +******************************************************************************/
|
| +
|
| +/*
|
| +** This vector defines all the methods that can operate on an
|
| +** sqlite3_file for win32.
|
| +*/
|
| +static const sqlite3_io_methods winIoMethod = {
|
| + 2, /* iVersion */
|
| + winClose, /* xClose */
|
| + winRead, /* xRead */
|
| + winWrite, /* xWrite */
|
| + winTruncate, /* xTruncate */
|
| + winSync, /* xSync */
|
| + winFileSize, /* xFileSize */
|
| + winLock, /* xLock */
|
| + winUnlock, /* xUnlock */
|
| + winCheckReservedLock, /* xCheckReservedLock */
|
| + winFileControl, /* xFileControl */
|
| + winSectorSize, /* xSectorSize */
|
| + winDeviceCharacteristics, /* xDeviceCharacteristics */
|
| + winShmMap, /* xShmMap */
|
| + winShmLock, /* xShmLock */
|
| + winShmBarrier, /* xShmBarrier */
|
| + winShmUnmap /* xShmUnmap */
|
| +};
|
| +
|
| +/****************************************************************************
|
| +**************************** sqlite3_vfs methods ****************************
|
| +**
|
| +** This division contains the implementation of methods on the
|
| +** sqlite3_vfs object.
|
| +*/
|
| +
|
| +/*
|
| +** Convert a UTF-8 filename into whatever form the underlying
|
| +** operating system wants filenames in. Space to hold the result
|
| +** is obtained from malloc and must be freed by the calling
|
| +** function.
|
| +*/
|
| +static void *convertUtf8Filename(const char *zFilename){
|
| + void *zConverted = 0;
|
| + if( isNT() ){
|
| + zConverted = utf8ToUnicode(zFilename);
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + zConverted = utf8ToMbcs(zFilename);
|
| +#endif
|
| + }
|
| + /* caller will handle out of memory */
|
| + return zConverted;
|
| +}
|
| +
|
| +/*
|
| +** Create a temporary file name in zBuf. zBuf must be big enough to
|
| +** hold at pVfs->mxPathname characters.
|
| +*/
|
| +static int getTempname(int nBuf, char *zBuf){
|
| + static char zChars[] =
|
| + "abcdefghijklmnopqrstuvwxyz"
|
| + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
| + "0123456789";
|
| + size_t i, j;
|
| + char zTempPath[MAX_PATH+1];
|
| +
|
| + /* It's odd to simulate an io-error here, but really this is just
|
| + ** using the io-error infrastructure to test that SQLite handles this
|
| + ** function failing.
|
| + */
|
| + SimulateIOError( return SQLITE_IOERR );
|
| +
|
| + if( sqlite3_temp_directory ){
|
| + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
|
| + }else if( isNT() ){
|
| + char *zMulti;
|
| + WCHAR zWidePath[MAX_PATH];
|
| + GetTempPathW(MAX_PATH-30, zWidePath);
|
| + zMulti = unicodeToUtf8(zWidePath);
|
| + if( zMulti ){
|
| + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
|
| + free(zMulti);
|
| + }else{
|
| + return SQLITE_NOMEM;
|
| + }
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + char *zUtf8;
|
| + char zMbcsPath[MAX_PATH];
|
| + GetTempPathA(MAX_PATH-30, zMbcsPath);
|
| + zUtf8 = sqlite3_win32_mbcs_to_utf8(zMbcsPath);
|
| + if( zUtf8 ){
|
| + sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
|
| + free(zUtf8);
|
| + }else{
|
| + return SQLITE_NOMEM;
|
| + }
|
| +#endif
|
| + }
|
| +
|
| + /* Check that the output buffer is large enough for the temporary file
|
| + ** name. If it is not, return SQLITE_ERROR.
|
| + */
|
| + if( (sqlite3Strlen30(zTempPath) + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 17) >= nBuf ){
|
| + return SQLITE_ERROR;
|
| + }
|
| +
|
| + for(i=sqlite3Strlen30(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
|
| + zTempPath[i] = 0;
|
| +
|
| + sqlite3_snprintf(nBuf-17, zBuf,
|
| + "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
|
| + j = sqlite3Strlen30(zBuf);
|
| + sqlite3_randomness(15, &zBuf[j]);
|
| + for(i=0; i<15; i++, j++){
|
| + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
|
| + }
|
| + zBuf[j] = 0;
|
| +
|
| + OSTRACE(("TEMP FILENAME: %s\n", zBuf));
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** The return value of getLastErrorMsg
|
| +** is zero if the error message fits in the buffer, or non-zero
|
| +** otherwise (if the message was truncated).
|
| +*/
|
| +static int getLastErrorMsg(int nBuf, char *zBuf){
|
| + /* FormatMessage returns 0 on failure. Otherwise it
|
| + ** returns the number of TCHARs written to the output
|
| + ** buffer, excluding the terminating null char.
|
| + */
|
| + DWORD error = GetLastError();
|
| + DWORD dwLen = 0;
|
| + char *zOut = 0;
|
| +
|
| + if( isNT() ){
|
| + WCHAR *zTempWide = NULL;
|
| + dwLen = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
| + NULL,
|
| + error,
|
| + 0,
|
| + (LPWSTR) &zTempWide,
|
| + 0,
|
| + 0);
|
| + if( dwLen > 0 ){
|
| + /* allocate a buffer and convert to UTF8 */
|
| + zOut = unicodeToUtf8(zTempWide);
|
| + /* free the system buffer allocated by FormatMessage */
|
| + LocalFree(zTempWide);
|
| + }
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + char *zTemp = NULL;
|
| + dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
| + NULL,
|
| + error,
|
| + 0,
|
| + (LPSTR) &zTemp,
|
| + 0,
|
| + 0);
|
| + if( dwLen > 0 ){
|
| + /* allocate a buffer and convert to UTF8 */
|
| + zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
|
| + /* free the system buffer allocated by FormatMessage */
|
| + LocalFree(zTemp);
|
| + }
|
| +#endif
|
| + }
|
| + if( 0 == dwLen ){
|
| + sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", error, error);
|
| + }else{
|
| + /* copy a maximum of nBuf chars to output buffer */
|
| + sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
|
| + /* free the UTF8 buffer */
|
| + free(zOut);
|
| + }
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Open a file.
|
| +*/
|
| +static int winOpen(
|
| + sqlite3_vfs *pVfs, /* Not used */
|
| + const char *zName, /* Name of the file (UTF-8) */
|
| + sqlite3_file *id, /* Write the SQLite file handle here */
|
| + int flags, /* Open mode flags */
|
| + int *pOutFlags /* Status return flags */
|
| +){
|
| + HANDLE h;
|
| + DWORD dwDesiredAccess;
|
| + DWORD dwShareMode;
|
| + DWORD dwCreationDisposition;
|
| + DWORD dwFlagsAndAttributes = 0;
|
| +#if SQLITE_OS_WINCE
|
| + int isTemp = 0;
|
| +#endif
|
| + winFile *pFile = (winFile*)id;
|
| + void *zConverted; /* Filename in OS encoding */
|
| + const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
|
| +
|
| + /* If argument zPath is a NULL pointer, this function is required to open
|
| + ** a temporary file. Use this buffer to store the file name in.
|
| + */
|
| + char zTmpname[MAX_PATH+1]; /* Buffer used to create temp filename */
|
| +
|
| + int rc = SQLITE_OK; /* Function Return Code */
|
| +#if !defined(NDEBUG) || SQLITE_OS_WINCE
|
| + int eType = flags&0xFFFFFF00; /* Type of file to open */
|
| +#endif
|
| +
|
| + int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
|
| + int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
|
| + int isCreate = (flags & SQLITE_OPEN_CREATE);
|
| +#ifndef NDEBUG
|
| + int isReadonly = (flags & SQLITE_OPEN_READONLY);
|
| +#endif
|
| + int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
|
| +
|
| +#ifndef NDEBUG
|
| + int isOpenJournal = (isCreate && (
|
| + eType==SQLITE_OPEN_MASTER_JOURNAL
|
| + || eType==SQLITE_OPEN_MAIN_JOURNAL
|
| + || eType==SQLITE_OPEN_WAL
|
| + ));
|
| +#endif
|
| +
|
| + /* Check the following statements are true:
|
| + **
|
| + ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
|
| + ** (b) if CREATE is set, then READWRITE must also be set, and
|
| + ** (c) if EXCLUSIVE is set, then CREATE must also be set.
|
| + ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
|
| + */
|
| + assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
|
| + assert(isCreate==0 || isReadWrite);
|
| + assert(isExclusive==0 || isCreate);
|
| + assert(isDelete==0 || isCreate);
|
| +
|
| + /* The main DB, main journal, WAL file and master journal are never
|
| + ** automatically deleted. Nor are they ever temporary files. */
|
| + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
|
| + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
|
| + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
|
| + assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
|
| +
|
| + /* Assert that the upper layer has set one of the "file-type" flags. */
|
| + assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
|
| + || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
|
| + || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
|
| + || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
|
| + );
|
| +
|
| + assert( id!=0 );
|
| + UNUSED_PARAMETER(pVfs);
|
| +
|
| + pFile->h = INVALID_HANDLE_VALUE;
|
| +
|
| + /* If the second argument to this function is NULL, generate a
|
| + ** temporary file name to use
|
| + */
|
| + if( !zUtf8Name ){
|
| + assert(isDelete && !isOpenJournal);
|
| + rc = getTempname(MAX_PATH+1, zTmpname);
|
| + if( rc!=SQLITE_OK ){
|
| + return rc;
|
| + }
|
| + zUtf8Name = zTmpname;
|
| + }
|
| +
|
| + /* Convert the filename to the system encoding. */
|
| + zConverted = convertUtf8Filename(zUtf8Name);
|
| + if( zConverted==0 ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| +
|
| + if( isReadWrite ){
|
| + dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
|
| + }else{
|
| + dwDesiredAccess = GENERIC_READ;
|
| + }
|
| +
|
| + /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
|
| + ** created. SQLite doesn't use it to indicate "exclusive access"
|
| + ** as it is usually understood.
|
| + */
|
| + if( isExclusive ){
|
| + /* Creates a new file, only if it does not already exist. */
|
| + /* If the file exists, it fails. */
|
| + dwCreationDisposition = CREATE_NEW;
|
| + }else if( isCreate ){
|
| + /* Open existing file, or create if it doesn't exist */
|
| + dwCreationDisposition = OPEN_ALWAYS;
|
| + }else{
|
| + /* Opens a file, only if it exists. */
|
| + dwCreationDisposition = OPEN_EXISTING;
|
| + }
|
| +
|
| + dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
|
| +
|
| + if( isDelete ){
|
| +#if SQLITE_OS_WINCE
|
| + dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
|
| + isTemp = 1;
|
| +#else
|
| + dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
|
| + | FILE_ATTRIBUTE_HIDDEN
|
| + | FILE_FLAG_DELETE_ON_CLOSE;
|
| +#endif
|
| + }else{
|
| + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
|
| + }
|
| + /* Reports from the internet are that performance is always
|
| + ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
|
| +#if SQLITE_OS_WINCE
|
| + dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
|
| +#endif
|
| +
|
| + if( isNT() ){
|
| + h = CreateFileW((WCHAR*)zConverted,
|
| + dwDesiredAccess,
|
| + dwShareMode,
|
| + NULL,
|
| + dwCreationDisposition,
|
| + dwFlagsAndAttributes,
|
| + NULL
|
| + );
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + h = CreateFileA((char*)zConverted,
|
| + dwDesiredAccess,
|
| + dwShareMode,
|
| + NULL,
|
| + dwCreationDisposition,
|
| + dwFlagsAndAttributes,
|
| + NULL
|
| + );
|
| +#endif
|
| + }
|
| +
|
| + OSTRACE(("OPEN %d %s 0x%lx %s\n",
|
| + h, zName, dwDesiredAccess,
|
| + h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
|
| +
|
| + if( h==INVALID_HANDLE_VALUE ){
|
| + pFile->lastErrno = GetLastError();
|
| + free(zConverted);
|
| + if( isReadWrite ){
|
| + return winOpen(pVfs, zName, id,
|
| + ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), pOutFlags);
|
| + }else{
|
| + return SQLITE_CANTOPEN_BKPT;
|
| + }
|
| + }
|
| +
|
| + if( pOutFlags ){
|
| + if( isReadWrite ){
|
| + *pOutFlags = SQLITE_OPEN_READWRITE;
|
| + }else{
|
| + *pOutFlags = SQLITE_OPEN_READONLY;
|
| + }
|
| + }
|
| +
|
| + memset(pFile, 0, sizeof(*pFile));
|
| + pFile->pMethod = &winIoMethod;
|
| + pFile->h = h;
|
| + pFile->lastErrno = NO_ERROR;
|
| + pFile->pVfs = pVfs;
|
| + pFile->pShm = 0;
|
| + pFile->zPath = zName;
|
| + pFile->sectorSize = getSectorSize(pVfs, zUtf8Name);
|
| +
|
| +#if SQLITE_OS_WINCE
|
| + if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB
|
| + && !winceCreateLock(zName, pFile)
|
| + ){
|
| + CloseHandle(h);
|
| + free(zConverted);
|
| + return SQLITE_CANTOPEN_BKPT;
|
| + }
|
| + if( isTemp ){
|
| + pFile->zDeleteOnClose = zConverted;
|
| + }else
|
| +#endif
|
| + {
|
| + free(zConverted);
|
| + }
|
| +
|
| + OpenCounter(+1);
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** Delete the named file.
|
| +**
|
| +** Note that windows does not allow a file to be deleted if some other
|
| +** process has it open. Sometimes a virus scanner or indexing program
|
| +** will open a journal file shortly after it is created in order to do
|
| +** whatever it does. While this other process is holding the
|
| +** file open, we will be unable to delete it. To work around this
|
| +** problem, we delay 100 milliseconds and try to delete again. Up
|
| +** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
|
| +** up and returning an error.
|
| +*/
|
| +#define MX_DELETION_ATTEMPTS 5
|
| +static int winDelete(
|
| + sqlite3_vfs *pVfs, /* Not used on win32 */
|
| + const char *zFilename, /* Name of file to delete */
|
| + int syncDir /* Not used on win32 */
|
| +){
|
| + int cnt = 0;
|
| + DWORD rc;
|
| + DWORD error = 0;
|
| + void *zConverted;
|
| + UNUSED_PARAMETER(pVfs);
|
| + UNUSED_PARAMETER(syncDir);
|
| +
|
| + SimulateIOError(return SQLITE_IOERR_DELETE);
|
| + zConverted = convertUtf8Filename(zFilename);
|
| + if( zConverted==0 ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| + if( isNT() ){
|
| + do{
|
| + DeleteFileW(zConverted);
|
| + }while( ( ((rc = GetFileAttributesW(zConverted)) != INVALID_FILE_ATTRIBUTES)
|
| + || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
|
| + && (++cnt < MX_DELETION_ATTEMPTS)
|
| + && (Sleep(100), 1) );
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + do{
|
| + DeleteFileA(zConverted);
|
| + }while( ( ((rc = GetFileAttributesA(zConverted)) != INVALID_FILE_ATTRIBUTES)
|
| + || ((error = GetLastError()) == ERROR_ACCESS_DENIED))
|
| + && (++cnt < MX_DELETION_ATTEMPTS)
|
| + && (Sleep(100), 1) );
|
| +#endif
|
| + }
|
| + free(zConverted);
|
| + OSTRACE(("DELETE \"%s\" %s\n", zFilename,
|
| + ( (rc==INVALID_FILE_ATTRIBUTES) && (error==ERROR_FILE_NOT_FOUND)) ?
|
| + "ok" : "failed" ));
|
| +
|
| + return ( (rc == INVALID_FILE_ATTRIBUTES)
|
| + && (error == ERROR_FILE_NOT_FOUND)) ? SQLITE_OK : SQLITE_IOERR_DELETE;
|
| +}
|
| +
|
| +/*
|
| +** Check the existance and status of a file.
|
| +*/
|
| +static int winAccess(
|
| + sqlite3_vfs *pVfs, /* Not used on win32 */
|
| + const char *zFilename, /* Name of file to check */
|
| + int flags, /* Type of test to make on this file */
|
| + int *pResOut /* OUT: Result */
|
| +){
|
| + DWORD attr;
|
| + int rc = 0;
|
| + void *zConverted;
|
| + UNUSED_PARAMETER(pVfs);
|
| +
|
| + SimulateIOError( return SQLITE_IOERR_ACCESS; );
|
| + zConverted = convertUtf8Filename(zFilename);
|
| + if( zConverted==0 ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| + if( isNT() ){
|
| + WIN32_FILE_ATTRIBUTE_DATA sAttrData;
|
| + memset(&sAttrData, 0, sizeof(sAttrData));
|
| + if( GetFileAttributesExW((WCHAR*)zConverted,
|
| + GetFileExInfoStandard,
|
| + &sAttrData) ){
|
| + /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
|
| + ** as if it does not exist.
|
| + */
|
| + if( flags==SQLITE_ACCESS_EXISTS
|
| + && sAttrData.nFileSizeHigh==0
|
| + && sAttrData.nFileSizeLow==0 ){
|
| + attr = INVALID_FILE_ATTRIBUTES;
|
| + }else{
|
| + attr = sAttrData.dwFileAttributes;
|
| + }
|
| + }else{
|
| + if( GetLastError()!=ERROR_FILE_NOT_FOUND ){
|
| + free(zConverted);
|
| + return SQLITE_IOERR_ACCESS;
|
| + }else{
|
| + attr = INVALID_FILE_ATTRIBUTES;
|
| + }
|
| + }
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + attr = GetFileAttributesA((char*)zConverted);
|
| +#endif
|
| + }
|
| + free(zConverted);
|
| + switch( flags ){
|
| + case SQLITE_ACCESS_READ:
|
| + case SQLITE_ACCESS_EXISTS:
|
| + rc = attr!=INVALID_FILE_ATTRIBUTES;
|
| + break;
|
| + case SQLITE_ACCESS_READWRITE:
|
| + rc = (attr & FILE_ATTRIBUTE_READONLY)==0;
|
| + break;
|
| + default:
|
| + assert(!"Invalid flags argument");
|
| + }
|
| + *pResOut = rc;
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Turn a relative pathname into a full pathname. Write the full
|
| +** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
|
| +** bytes in size.
|
| +*/
|
| +static int winFullPathname(
|
| + sqlite3_vfs *pVfs, /* Pointer to vfs object */
|
| + const char *zRelative, /* Possibly relative input path */
|
| + int nFull, /* Size of output buffer in bytes */
|
| + char *zFull /* Output buffer */
|
| +){
|
| +
|
| +#if defined(__CYGWIN__)
|
| + SimulateIOError( return SQLITE_ERROR );
|
| + UNUSED_PARAMETER(nFull);
|
| + cygwin_conv_to_full_win32_path(zRelative, zFull);
|
| + return SQLITE_OK;
|
| +#endif
|
| +
|
| +#if SQLITE_OS_WINCE
|
| + SimulateIOError( return SQLITE_ERROR );
|
| + UNUSED_PARAMETER(nFull);
|
| + /* WinCE has no concept of a relative pathname, or so I am told. */
|
| + sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
|
| + return SQLITE_OK;
|
| +#endif
|
| +
|
| +#if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
|
| + int nByte;
|
| + void *zConverted;
|
| + char *zOut;
|
| +
|
| + /* It's odd to simulate an io-error here, but really this is just
|
| + ** using the io-error infrastructure to test that SQLite handles this
|
| + ** function failing. This function could fail if, for example, the
|
| + ** current working directory has been unlinked.
|
| + */
|
| + SimulateIOError( return SQLITE_ERROR );
|
| + UNUSED_PARAMETER(nFull);
|
| + zConverted = convertUtf8Filename(zRelative);
|
| + if( isNT() ){
|
| + WCHAR *zTemp;
|
| + nByte = GetFullPathNameW((WCHAR*)zConverted, 0, 0, 0) + 3;
|
| + zTemp = malloc( nByte*sizeof(zTemp[0]) );
|
| + if( zTemp==0 ){
|
| + free(zConverted);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + GetFullPathNameW((WCHAR*)zConverted, nByte, zTemp, 0);
|
| + free(zConverted);
|
| + zOut = unicodeToUtf8(zTemp);
|
| + free(zTemp);
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + char *zTemp;
|
| + nByte = GetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
|
| + zTemp = malloc( nByte*sizeof(zTemp[0]) );
|
| + if( zTemp==0 ){
|
| + free(zConverted);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + GetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
|
| + free(zConverted);
|
| + zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
|
| + free(zTemp);
|
| +#endif
|
| + }
|
| + if( zOut ){
|
| + sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
|
| + free(zOut);
|
| + return SQLITE_OK;
|
| + }else{
|
| + return SQLITE_NOMEM;
|
| + }
|
| +#endif
|
| +}
|
| +
|
| +/*
|
| +** Get the sector size of the device used to store
|
| +** file.
|
| +*/
|
| +static int getSectorSize(
|
| + sqlite3_vfs *pVfs,
|
| + const char *zRelative /* UTF-8 file name */
|
| +){
|
| + DWORD bytesPerSector = SQLITE_DEFAULT_SECTOR_SIZE;
|
| + /* GetDiskFreeSpace is not supported under WINCE */
|
| +#if SQLITE_OS_WINCE
|
| + UNUSED_PARAMETER(pVfs);
|
| + UNUSED_PARAMETER(zRelative);
|
| +#else
|
| + char zFullpath[MAX_PATH+1];
|
| + int rc;
|
| + DWORD dwRet = 0;
|
| + DWORD dwDummy;
|
| +
|
| + /*
|
| + ** We need to get the full path name of the file
|
| + ** to get the drive letter to look up the sector
|
| + ** size.
|
| + */
|
| + SimulateIOErrorBenign(1);
|
| + rc = winFullPathname(pVfs, zRelative, MAX_PATH, zFullpath);
|
| + SimulateIOErrorBenign(0);
|
| + if( rc == SQLITE_OK )
|
| + {
|
| + void *zConverted = convertUtf8Filename(zFullpath);
|
| + if( zConverted ){
|
| + if( isNT() ){
|
| + /* trim path to just drive reference */
|
| + WCHAR *p = zConverted;
|
| + for(;*p;p++){
|
| + if( *p == '\\' ){
|
| + *p = '\0';
|
| + break;
|
| + }
|
| + }
|
| + dwRet = GetDiskFreeSpaceW((WCHAR*)zConverted,
|
| + &dwDummy,
|
| + &bytesPerSector,
|
| + &dwDummy,
|
| + &dwDummy);
|
| + }else{
|
| + /* trim path to just drive reference */
|
| + char *p = (char *)zConverted;
|
| + for(;*p;p++){
|
| + if( *p == '\\' ){
|
| + *p = '\0';
|
| + break;
|
| + }
|
| + }
|
| + dwRet = GetDiskFreeSpaceA((char*)zConverted,
|
| + &dwDummy,
|
| + &bytesPerSector,
|
| + &dwDummy,
|
| + &dwDummy);
|
| + }
|
| + free(zConverted);
|
| + }
|
| + if( !dwRet ){
|
| + bytesPerSector = SQLITE_DEFAULT_SECTOR_SIZE;
|
| + }
|
| + }
|
| +#endif
|
| + return (int) bytesPerSector;
|
| +}
|
| +
|
| +#ifndef SQLITE_OMIT_LOAD_EXTENSION
|
| +/*
|
| +** Interfaces for opening a shared library, finding entry points
|
| +** within the shared library, and closing the shared library.
|
| +*/
|
| +/*
|
| +** Interfaces for opening a shared library, finding entry points
|
| +** within the shared library, and closing the shared library.
|
| +*/
|
| +static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
|
| + HANDLE h;
|
| + void *zConverted = convertUtf8Filename(zFilename);
|
| + UNUSED_PARAMETER(pVfs);
|
| + if( zConverted==0 ){
|
| + return 0;
|
| + }
|
| + if( isNT() ){
|
| + h = LoadLibraryW((WCHAR*)zConverted);
|
| +/* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
|
| +** Since the ASCII version of these Windows API do not exist for WINCE,
|
| +** it's important to not reference them for WINCE builds.
|
| +*/
|
| +#if SQLITE_OS_WINCE==0
|
| + }else{
|
| + h = LoadLibraryA((char*)zConverted);
|
| +#endif
|
| + }
|
| + free(zConverted);
|
| + return (void*)h;
|
| +}
|
| +static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
|
| + UNUSED_PARAMETER(pVfs);
|
| + getLastErrorMsg(nBuf, zBufOut);
|
| +}
|
| +void (*winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
|
| + UNUSED_PARAMETER(pVfs);
|
| +#if SQLITE_OS_WINCE
|
| + /* The GetProcAddressA() routine is only available on wince. */
|
| + return (void(*)(void))GetProcAddressA((HANDLE)pHandle, zSymbol);
|
| +#else
|
| + /* All other windows platforms expect GetProcAddress() to take
|
| + ** an Ansi string regardless of the _UNICODE setting */
|
| + return (void(*)(void))GetProcAddress((HANDLE)pHandle, zSymbol);
|
| +#endif
|
| +}
|
| +void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
|
| + UNUSED_PARAMETER(pVfs);
|
| + FreeLibrary((HANDLE)pHandle);
|
| +}
|
| +#else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
|
| + #define winDlOpen 0
|
| + #define winDlError 0
|
| + #define winDlSym 0
|
| + #define winDlClose 0
|
| +#endif
|
| +
|
| +
|
| +/*
|
| +** Write up to nBuf bytes of randomness into zBuf.
|
| +*/
|
| +static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
|
| + int n = 0;
|
| + UNUSED_PARAMETER(pVfs);
|
| +#if defined(SQLITE_TEST)
|
| + n = nBuf;
|
| + memset(zBuf, 0, nBuf);
|
| +#else
|
| + if( sizeof(SYSTEMTIME)<=nBuf-n ){
|
| + SYSTEMTIME x;
|
| + GetSystemTime(&x);
|
| + memcpy(&zBuf[n], &x, sizeof(x));
|
| + n += sizeof(x);
|
| + }
|
| + if( sizeof(DWORD)<=nBuf-n ){
|
| + DWORD pid = GetCurrentProcessId();
|
| + memcpy(&zBuf[n], &pid, sizeof(pid));
|
| + n += sizeof(pid);
|
| + }
|
| + if( sizeof(DWORD)<=nBuf-n ){
|
| + DWORD cnt = GetTickCount();
|
| + memcpy(&zBuf[n], &cnt, sizeof(cnt));
|
| + n += sizeof(cnt);
|
| + }
|
| + if( sizeof(LARGE_INTEGER)<=nBuf-n ){
|
| + LARGE_INTEGER i;
|
| + QueryPerformanceCounter(&i);
|
| + memcpy(&zBuf[n], &i, sizeof(i));
|
| + n += sizeof(i);
|
| + }
|
| +#endif
|
| + return n;
|
| +}
|
| +
|
| +
|
| +/*
|
| +** Sleep for a little while. Return the amount of time slept.
|
| +*/
|
| +static int winSleep(sqlite3_vfs *pVfs, int microsec){
|
| + Sleep((microsec+999)/1000);
|
| + UNUSED_PARAMETER(pVfs);
|
| + return ((microsec+999)/1000)*1000;
|
| +}
|
| +
|
| +/*
|
| +** The following variable, if set to a non-zero value, is interpreted as
|
| +** the number of seconds since 1970 and is used to set the result of
|
| +** sqlite3OsCurrentTime() during testing.
|
| +*/
|
| +#ifdef SQLITE_TEST
|
| +int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
|
| +#endif
|
| +
|
| +/*
|
| +** Find the current time (in Universal Coordinated Time). Write into *piNow
|
| +** the current time and date as a Julian Day number times 86_400_000. In
|
| +** other words, write into *piNow the number of milliseconds since the Julian
|
| +** epoch of noon in Greenwich on November 24, 4714 B.C according to the
|
| +** proleptic Gregorian calendar.
|
| +**
|
| +** On success, return 0. Return 1 if the time and date cannot be found.
|
| +*/
|
| +static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
|
| + /* FILETIME structure is a 64-bit value representing the number of
|
| + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
|
| + */
|
| + FILETIME ft;
|
| + static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000;
|
| +#ifdef SQLITE_TEST
|
| + static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
|
| +#endif
|
| + /* 2^32 - to avoid use of LL and warnings in gcc */
|
| + static const sqlite3_int64 max32BitValue =
|
| + (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + (sqlite3_int64)294967296;
|
| +
|
| +#if SQLITE_OS_WINCE
|
| + SYSTEMTIME time;
|
| + GetSystemTime(&time);
|
| + /* if SystemTimeToFileTime() fails, it returns zero. */
|
| + if (!SystemTimeToFileTime(&time,&ft)){
|
| + return 1;
|
| + }
|
| +#else
|
| + GetSystemTimeAsFileTime( &ft );
|
| +#endif
|
| +
|
| + *piNow = winFiletimeEpoch +
|
| + ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) +
|
| + (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000;
|
| +
|
| +#ifdef SQLITE_TEST
|
| + if( sqlite3_current_time ){
|
| + *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
|
| + }
|
| +#endif
|
| + UNUSED_PARAMETER(pVfs);
|
| + return 0;
|
| +}
|
| +
|
| +/*
|
| +** Find the current time (in Universal Coordinated Time). Write the
|
| +** current time and date as a Julian Day number into *prNow and
|
| +** return 0. Return 1 if the time and date cannot be found.
|
| +*/
|
| +int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
|
| + int rc;
|
| + sqlite3_int64 i;
|
| + rc = winCurrentTimeInt64(pVfs, &i);
|
| + if( !rc ){
|
| + *prNow = i/86400000.0;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/*
|
| +** The idea is that this function works like a combination of
|
| +** GetLastError() and FormatMessage() on windows (or errno and
|
| +** strerror_r() on unix). After an error is returned by an OS
|
| +** function, SQLite calls this function with zBuf pointing to
|
| +** a buffer of nBuf bytes. The OS layer should populate the
|
| +** buffer with a nul-terminated UTF-8 encoded error message
|
| +** describing the last IO error to have occurred within the calling
|
| +** thread.
|
| +**
|
| +** If the error message is too large for the supplied buffer,
|
| +** it should be truncated. The return value of xGetLastError
|
| +** is zero if the error message fits in the buffer, or non-zero
|
| +** otherwise (if the message was truncated). If non-zero is returned,
|
| +** then it is not necessary to include the nul-terminator character
|
| +** in the output buffer.
|
| +**
|
| +** Not supplying an error message will have no adverse effect
|
| +** on SQLite. It is fine to have an implementation that never
|
| +** returns an error message:
|
| +**
|
| +** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
|
| +** assert(zBuf[0]=='\0');
|
| +** return 0;
|
| +** }
|
| +**
|
| +** However if an error message is supplied, it will be incorporated
|
| +** by sqlite into the error message available to the user using
|
| +** sqlite3_errmsg(), possibly making IO errors easier to debug.
|
| +*/
|
| +static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
|
| + UNUSED_PARAMETER(pVfs);
|
| + return getLastErrorMsg(nBuf, zBuf);
|
| +}
|
| +
|
| +
|
| +
|
| +/*
|
| +** Initialize and deinitialize the operating system interface.
|
| +*/
|
| +int sqlite3_os_init(void){
|
| + static sqlite3_vfs winVfs = {
|
| + 3, /* iVersion */
|
| + sizeof(winFile), /* szOsFile */
|
| + MAX_PATH, /* mxPathname */
|
| + 0, /* pNext */
|
| + "win32", /* zName */
|
| + 0, /* pAppData */
|
| + winOpen, /* xOpen */
|
| + winDelete, /* xDelete */
|
| + winAccess, /* xAccess */
|
| + winFullPathname, /* xFullPathname */
|
| + winDlOpen, /* xDlOpen */
|
| + winDlError, /* xDlError */
|
| + winDlSym, /* xDlSym */
|
| + winDlClose, /* xDlClose */
|
| + winRandomness, /* xRandomness */
|
| + winSleep, /* xSleep */
|
| + winCurrentTime, /* xCurrentTime */
|
| + winGetLastError, /* xGetLastError */
|
| + winCurrentTimeInt64, /* xCurrentTimeInt64 */
|
| + 0, /* xSetSystemCall */
|
| + 0, /* xGetSystemCall */
|
| + 0, /* xNextSystemCall */
|
| + };
|
| +
|
| +#ifndef SQLITE_OMIT_WAL
|
| + /* get memory map allocation granularity */
|
| + memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
|
| + GetSystemInfo(&winSysInfo);
|
| + assert(winSysInfo.dwAllocationGranularity > 0);
|
| +#endif
|
| +
|
| + sqlite3_vfs_register(&winVfs, 1);
|
| + return SQLITE_OK;
|
| +}
|
| +int sqlite3_os_end(void){
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +void chromium_sqlite3_initialize_win_sqlite3_file(sqlite3_file* file, HANDLE handle) {
|
| + winFile* winSQLite3File = (winFile*)file;
|
| + memset(file, 0, sizeof(*file));
|
| + winSQLite3File->pMethod = &winIoMethod;
|
| + winSQLite3File->h = handle;
|
| +}
|
| +
|
| +#endif /* SQLITE_OS_WIN */
|
|
|
Chromium Code Reviews
Issue 694353003:
Get `gn gen` to succeed on Windows (Closed)
Base URL: https://github.com/domokit/mojo.git@master