Annotation of embedaddon/sqlite3/src/os_win.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2004 May 22
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: ******************************************************************************
! 12: **
! 13: ** This file contains code that is specific to Windows.
! 14: */
! 15: #include "sqliteInt.h"
! 16: #if SQLITE_OS_WIN /* This file is used for Windows only */
! 17:
! 18: #ifdef __CYGWIN__
! 19: # include <sys/cygwin.h>
! 20: #endif
! 21:
! 22: /*
! 23: ** Include code that is common to all os_*.c files
! 24: */
! 25: #include "os_common.h"
! 26:
! 27: /*
! 28: ** Some Microsoft compilers lack this definition.
! 29: */
! 30: #ifndef INVALID_FILE_ATTRIBUTES
! 31: # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
! 32: #endif
! 33:
! 34: /* Forward references */
! 35: typedef struct winShm winShm; /* A connection to shared-memory */
! 36: typedef struct winShmNode winShmNode; /* A region of shared-memory */
! 37:
! 38: /*
! 39: ** WinCE lacks native support for file locking so we have to fake it
! 40: ** with some code of our own.
! 41: */
! 42: #if SQLITE_OS_WINCE
! 43: typedef struct winceLock {
! 44: int nReaders; /* Number of reader locks obtained */
! 45: BOOL bPending; /* Indicates a pending lock has been obtained */
! 46: BOOL bReserved; /* Indicates a reserved lock has been obtained */
! 47: BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
! 48: } winceLock;
! 49: #endif
! 50:
! 51: /*
! 52: ** The winFile structure is a subclass of sqlite3_file* specific to the win32
! 53: ** portability layer.
! 54: */
! 55: typedef struct winFile winFile;
! 56: struct winFile {
! 57: const sqlite3_io_methods *pMethod; /*** Must be first ***/
! 58: sqlite3_vfs *pVfs; /* The VFS used to open this file */
! 59: HANDLE h; /* Handle for accessing the file */
! 60: u8 locktype; /* Type of lock currently held on this file */
! 61: short sharedLockByte; /* Randomly chosen byte used as a shared lock */
! 62: u8 ctrlFlags; /* Flags. See WINFILE_* below */
! 63: DWORD lastErrno; /* The Windows errno from the last I/O error */
! 64: winShm *pShm; /* Instance of shared memory on this file */
! 65: const char *zPath; /* Full pathname of this file */
! 66: int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
! 67: #if SQLITE_OS_WINCE
! 68: LPWSTR zDeleteOnClose; /* Name of file to delete when closing */
! 69: HANDLE hMutex; /* Mutex used to control access to shared lock */
! 70: HANDLE hShared; /* Shared memory segment used for locking */
! 71: winceLock local; /* Locks obtained by this instance of winFile */
! 72: winceLock *shared; /* Global shared lock memory for the file */
! 73: #endif
! 74: };
! 75:
! 76: /*
! 77: ** Allowed values for winFile.ctrlFlags
! 78: */
! 79: #define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
! 80: #define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
! 81:
! 82: /*
! 83: * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the
! 84: * various Win32 API heap functions instead of our own.
! 85: */
! 86: #ifdef SQLITE_WIN32_MALLOC
! 87: /*
! 88: * The initial size of the Win32-specific heap. This value may be zero.
! 89: */
! 90: #ifndef SQLITE_WIN32_HEAP_INIT_SIZE
! 91: # define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_DEFAULT_CACHE_SIZE) * \
! 92: (SQLITE_DEFAULT_PAGE_SIZE) + 4194304)
! 93: #endif
! 94:
! 95: /*
! 96: * The maximum size of the Win32-specific heap. This value may be zero.
! 97: */
! 98: #ifndef SQLITE_WIN32_HEAP_MAX_SIZE
! 99: # define SQLITE_WIN32_HEAP_MAX_SIZE (0)
! 100: #endif
! 101:
! 102: /*
! 103: * The extra flags to use in calls to the Win32 heap APIs. This value may be
! 104: * zero for the default behavior.
! 105: */
! 106: #ifndef SQLITE_WIN32_HEAP_FLAGS
! 107: # define SQLITE_WIN32_HEAP_FLAGS (0)
! 108: #endif
! 109:
! 110: /*
! 111: ** The winMemData structure stores information required by the Win32-specific
! 112: ** sqlite3_mem_methods implementation.
! 113: */
! 114: typedef struct winMemData winMemData;
! 115: struct winMemData {
! 116: #ifndef NDEBUG
! 117: u32 magic; /* Magic number to detect structure corruption. */
! 118: #endif
! 119: HANDLE hHeap; /* The handle to our heap. */
! 120: BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */
! 121: };
! 122:
! 123: #ifndef NDEBUG
! 124: #define WINMEM_MAGIC 0x42b2830b
! 125: #endif
! 126:
! 127: static struct winMemData win_mem_data = {
! 128: #ifndef NDEBUG
! 129: WINMEM_MAGIC,
! 130: #endif
! 131: NULL, FALSE
! 132: };
! 133:
! 134: #ifndef NDEBUG
! 135: #define winMemAssertMagic() assert( win_mem_data.magic==WINMEM_MAGIC )
! 136: #else
! 137: #define winMemAssertMagic()
! 138: #endif
! 139:
! 140: #define winMemGetHeap() win_mem_data.hHeap
! 141:
! 142: static void *winMemMalloc(int nBytes);
! 143: static void winMemFree(void *pPrior);
! 144: static void *winMemRealloc(void *pPrior, int nBytes);
! 145: static int winMemSize(void *p);
! 146: static int winMemRoundup(int n);
! 147: static int winMemInit(void *pAppData);
! 148: static void winMemShutdown(void *pAppData);
! 149:
! 150: const sqlite3_mem_methods *sqlite3MemGetWin32(void);
! 151: #endif /* SQLITE_WIN32_MALLOC */
! 152:
! 153: /*
! 154: ** The following variable is (normally) set once and never changes
! 155: ** thereafter. It records whether the operating system is Win9x
! 156: ** or WinNT.
! 157: **
! 158: ** 0: Operating system unknown.
! 159: ** 1: Operating system is Win9x.
! 160: ** 2: Operating system is WinNT.
! 161: **
! 162: ** In order to facilitate testing on a WinNT system, the test fixture
! 163: ** can manually set this value to 1 to emulate Win98 behavior.
! 164: */
! 165: #ifdef SQLITE_TEST
! 166: int sqlite3_os_type = 0;
! 167: #else
! 168: static int sqlite3_os_type = 0;
! 169: #endif
! 170:
! 171: /*
! 172: ** Many system calls are accessed through pointer-to-functions so that
! 173: ** they may be overridden at runtime to facilitate fault injection during
! 174: ** testing and sandboxing. The following array holds the names and pointers
! 175: ** to all overrideable system calls.
! 176: */
! 177: #if !SQLITE_OS_WINCE
! 178: # define SQLITE_WIN32_HAS_ANSI
! 179: #endif
! 180:
! 181: #if SQLITE_OS_WINCE || SQLITE_OS_WINNT
! 182: # define SQLITE_WIN32_HAS_WIDE
! 183: #endif
! 184:
! 185: #ifndef SYSCALL
! 186: # define SYSCALL sqlite3_syscall_ptr
! 187: #endif
! 188:
! 189: #if SQLITE_OS_WINCE
! 190: /*
! 191: ** These macros are necessary because Windows CE does not natively support the
! 192: ** Win32 APIs LockFile, UnlockFile, and LockFileEx.
! 193: */
! 194:
! 195: # define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e)
! 196: # define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e)
! 197: # define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f)
! 198:
! 199: /*
! 200: ** These are the special syscall hacks for Windows CE. The locking related
! 201: ** defines here refer to the macros defined just above.
! 202: */
! 203:
! 204: # define osAreFileApisANSI() 1
! 205: # define osLockFile LockFile
! 206: # define osUnlockFile UnlockFile
! 207: # define osLockFileEx LockFileEx
! 208: #endif
! 209:
! 210: static struct win_syscall {
! 211: const char *zName; /* Name of the sytem call */
! 212: sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
! 213: sqlite3_syscall_ptr pDefault; /* Default value */
! 214: } aSyscall[] = {
! 215: #if !SQLITE_OS_WINCE
! 216: { "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 },
! 217:
! 218: #define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent)
! 219: #else
! 220: { "AreFileApisANSI", (SYSCALL)0, 0 },
! 221: #endif
! 222:
! 223: #if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
! 224: { "CharLowerW", (SYSCALL)CharLowerW, 0 },
! 225: #else
! 226: { "CharLowerW", (SYSCALL)0, 0 },
! 227: #endif
! 228:
! 229: #define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent)
! 230:
! 231: #if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
! 232: { "CharUpperW", (SYSCALL)CharUpperW, 0 },
! 233: #else
! 234: { "CharUpperW", (SYSCALL)0, 0 },
! 235: #endif
! 236:
! 237: #define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent)
! 238:
! 239: { "CloseHandle", (SYSCALL)CloseHandle, 0 },
! 240:
! 241: #define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent)
! 242:
! 243: #if defined(SQLITE_WIN32_HAS_ANSI)
! 244: { "CreateFileA", (SYSCALL)CreateFileA, 0 },
! 245: #else
! 246: { "CreateFileA", (SYSCALL)0, 0 },
! 247: #endif
! 248:
! 249: #define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \
! 250: LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent)
! 251:
! 252: #if defined(SQLITE_WIN32_HAS_WIDE)
! 253: { "CreateFileW", (SYSCALL)CreateFileW, 0 },
! 254: #else
! 255: { "CreateFileW", (SYSCALL)0, 0 },
! 256: #endif
! 257:
! 258: #define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \
! 259: LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)
! 260:
! 261: { "CreateFileMapping", (SYSCALL)CreateFileMapping, 0 },
! 262:
! 263: #define osCreateFileMapping ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
! 264: DWORD,DWORD,DWORD,LPCTSTR))aSyscall[6].pCurrent)
! 265:
! 266: #if defined(SQLITE_WIN32_HAS_WIDE)
! 267: { "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 },
! 268: #else
! 269: { "CreateFileMappingW", (SYSCALL)0, 0 },
! 270: #endif
! 271:
! 272: #define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
! 273: DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent)
! 274:
! 275: #if defined(SQLITE_WIN32_HAS_WIDE)
! 276: { "CreateMutexW", (SYSCALL)CreateMutexW, 0 },
! 277: #else
! 278: { "CreateMutexW", (SYSCALL)0, 0 },
! 279: #endif
! 280:
! 281: #define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \
! 282: LPCWSTR))aSyscall[8].pCurrent)
! 283:
! 284: #if defined(SQLITE_WIN32_HAS_ANSI)
! 285: { "DeleteFileA", (SYSCALL)DeleteFileA, 0 },
! 286: #else
! 287: { "DeleteFileA", (SYSCALL)0, 0 },
! 288: #endif
! 289:
! 290: #define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent)
! 291:
! 292: #if defined(SQLITE_WIN32_HAS_WIDE)
! 293: { "DeleteFileW", (SYSCALL)DeleteFileW, 0 },
! 294: #else
! 295: { "DeleteFileW", (SYSCALL)0, 0 },
! 296: #endif
! 297:
! 298: #define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent)
! 299:
! 300: #if SQLITE_OS_WINCE
! 301: { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 },
! 302: #else
! 303: { "FileTimeToLocalFileTime", (SYSCALL)0, 0 },
! 304: #endif
! 305:
! 306: #define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \
! 307: LPFILETIME))aSyscall[11].pCurrent)
! 308:
! 309: #if SQLITE_OS_WINCE
! 310: { "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 },
! 311: #else
! 312: { "FileTimeToSystemTime", (SYSCALL)0, 0 },
! 313: #endif
! 314:
! 315: #define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \
! 316: LPSYSTEMTIME))aSyscall[12].pCurrent)
! 317:
! 318: { "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 },
! 319:
! 320: #define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent)
! 321:
! 322: #if defined(SQLITE_WIN32_HAS_ANSI)
! 323: { "FormatMessageA", (SYSCALL)FormatMessageA, 0 },
! 324: #else
! 325: { "FormatMessageA", (SYSCALL)0, 0 },
! 326: #endif
! 327:
! 328: #define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \
! 329: DWORD,va_list*))aSyscall[14].pCurrent)
! 330:
! 331: #if defined(SQLITE_WIN32_HAS_WIDE)
! 332: { "FormatMessageW", (SYSCALL)FormatMessageW, 0 },
! 333: #else
! 334: { "FormatMessageW", (SYSCALL)0, 0 },
! 335: #endif
! 336:
! 337: #define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \
! 338: DWORD,va_list*))aSyscall[15].pCurrent)
! 339:
! 340: { "FreeLibrary", (SYSCALL)FreeLibrary, 0 },
! 341:
! 342: #define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent)
! 343:
! 344: { "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 },
! 345:
! 346: #define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent)
! 347:
! 348: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
! 349: { "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 },
! 350: #else
! 351: { "GetDiskFreeSpaceA", (SYSCALL)0, 0 },
! 352: #endif
! 353:
! 354: #define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \
! 355: LPDWORD))aSyscall[18].pCurrent)
! 356:
! 357: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
! 358: { "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 },
! 359: #else
! 360: { "GetDiskFreeSpaceW", (SYSCALL)0, 0 },
! 361: #endif
! 362:
! 363: #define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \
! 364: LPDWORD))aSyscall[19].pCurrent)
! 365:
! 366: #if defined(SQLITE_WIN32_HAS_ANSI)
! 367: { "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 },
! 368: #else
! 369: { "GetFileAttributesA", (SYSCALL)0, 0 },
! 370: #endif
! 371:
! 372: #define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent)
! 373:
! 374: #if defined(SQLITE_WIN32_HAS_WIDE)
! 375: { "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 },
! 376: #else
! 377: { "GetFileAttributesW", (SYSCALL)0, 0 },
! 378: #endif
! 379:
! 380: #define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent)
! 381:
! 382: #if defined(SQLITE_WIN32_HAS_WIDE)
! 383: { "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 },
! 384: #else
! 385: { "GetFileAttributesExW", (SYSCALL)0, 0 },
! 386: #endif
! 387:
! 388: #define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \
! 389: LPVOID))aSyscall[22].pCurrent)
! 390:
! 391: { "GetFileSize", (SYSCALL)GetFileSize, 0 },
! 392:
! 393: #define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent)
! 394:
! 395: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
! 396: { "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 },
! 397: #else
! 398: { "GetFullPathNameA", (SYSCALL)0, 0 },
! 399: #endif
! 400:
! 401: #define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \
! 402: LPSTR*))aSyscall[24].pCurrent)
! 403:
! 404: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
! 405: { "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 },
! 406: #else
! 407: { "GetFullPathNameW", (SYSCALL)0, 0 },
! 408: #endif
! 409:
! 410: #define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \
! 411: LPWSTR*))aSyscall[25].pCurrent)
! 412:
! 413: { "GetLastError", (SYSCALL)GetLastError, 0 },
! 414:
! 415: #define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent)
! 416:
! 417: #if SQLITE_OS_WINCE
! 418: /* The GetProcAddressA() routine is only available on Windows CE. */
! 419: { "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 },
! 420: #else
! 421: /* All other Windows platforms expect GetProcAddress() to take
! 422: ** an ANSI string regardless of the _UNICODE setting */
! 423: { "GetProcAddressA", (SYSCALL)GetProcAddress, 0 },
! 424: #endif
! 425:
! 426: #define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \
! 427: LPCSTR))aSyscall[27].pCurrent)
! 428:
! 429: { "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 },
! 430:
! 431: #define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent)
! 432:
! 433: { "GetSystemTime", (SYSCALL)GetSystemTime, 0 },
! 434:
! 435: #define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent)
! 436:
! 437: #if !SQLITE_OS_WINCE
! 438: { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 },
! 439: #else
! 440: { "GetSystemTimeAsFileTime", (SYSCALL)0, 0 },
! 441: #endif
! 442:
! 443: #define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \
! 444: LPFILETIME))aSyscall[30].pCurrent)
! 445:
! 446: #if defined(SQLITE_WIN32_HAS_ANSI)
! 447: { "GetTempPathA", (SYSCALL)GetTempPathA, 0 },
! 448: #else
! 449: { "GetTempPathA", (SYSCALL)0, 0 },
! 450: #endif
! 451:
! 452: #define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent)
! 453:
! 454: #if defined(SQLITE_WIN32_HAS_WIDE)
! 455: { "GetTempPathW", (SYSCALL)GetTempPathW, 0 },
! 456: #else
! 457: { "GetTempPathW", (SYSCALL)0, 0 },
! 458: #endif
! 459:
! 460: #define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent)
! 461:
! 462: { "GetTickCount", (SYSCALL)GetTickCount, 0 },
! 463:
! 464: #define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)
! 465:
! 466: #if defined(SQLITE_WIN32_HAS_ANSI)
! 467: { "GetVersionExA", (SYSCALL)GetVersionExA, 0 },
! 468: #else
! 469: { "GetVersionExA", (SYSCALL)0, 0 },
! 470: #endif
! 471:
! 472: #define osGetVersionExA ((BOOL(WINAPI*)( \
! 473: LPOSVERSIONINFOA))aSyscall[34].pCurrent)
! 474:
! 475: { "HeapAlloc", (SYSCALL)HeapAlloc, 0 },
! 476:
! 477: #define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \
! 478: SIZE_T))aSyscall[35].pCurrent)
! 479:
! 480: { "HeapCreate", (SYSCALL)HeapCreate, 0 },
! 481:
! 482: #define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
! 483: SIZE_T))aSyscall[36].pCurrent)
! 484:
! 485: { "HeapDestroy", (SYSCALL)HeapDestroy, 0 },
! 486:
! 487: #define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[37].pCurrent)
! 488:
! 489: { "HeapFree", (SYSCALL)HeapFree, 0 },
! 490:
! 491: #define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[38].pCurrent)
! 492:
! 493: { "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 },
! 494:
! 495: #define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \
! 496: SIZE_T))aSyscall[39].pCurrent)
! 497:
! 498: { "HeapSize", (SYSCALL)HeapSize, 0 },
! 499:
! 500: #define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \
! 501: LPCVOID))aSyscall[40].pCurrent)
! 502:
! 503: { "HeapValidate", (SYSCALL)HeapValidate, 0 },
! 504:
! 505: #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
! 506: LPCVOID))aSyscall[41].pCurrent)
! 507:
! 508: #if defined(SQLITE_WIN32_HAS_ANSI)
! 509: { "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 },
! 510: #else
! 511: { "LoadLibraryA", (SYSCALL)0, 0 },
! 512: #endif
! 513:
! 514: #define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[42].pCurrent)
! 515:
! 516: #if defined(SQLITE_WIN32_HAS_WIDE)
! 517: { "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 },
! 518: #else
! 519: { "LoadLibraryW", (SYSCALL)0, 0 },
! 520: #endif
! 521:
! 522: #define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[43].pCurrent)
! 523:
! 524: { "LocalFree", (SYSCALL)LocalFree, 0 },
! 525:
! 526: #define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[44].pCurrent)
! 527:
! 528: #if !SQLITE_OS_WINCE
! 529: { "LockFile", (SYSCALL)LockFile, 0 },
! 530:
! 531: #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
! 532: DWORD))aSyscall[45].pCurrent)
! 533: #else
! 534: { "LockFile", (SYSCALL)0, 0 },
! 535: #endif
! 536:
! 537: #if !SQLITE_OS_WINCE
! 538: { "LockFileEx", (SYSCALL)LockFileEx, 0 },
! 539:
! 540: #define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
! 541: LPOVERLAPPED))aSyscall[46].pCurrent)
! 542: #else
! 543: { "LockFileEx", (SYSCALL)0, 0 },
! 544: #endif
! 545:
! 546: { "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 },
! 547:
! 548: #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
! 549: SIZE_T))aSyscall[47].pCurrent)
! 550:
! 551: { "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 },
! 552:
! 553: #define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \
! 554: int))aSyscall[48].pCurrent)
! 555:
! 556: { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },
! 557:
! 558: #define osQueryPerformanceCounter ((BOOL(WINAPI*)( \
! 559: LARGE_INTEGER*))aSyscall[49].pCurrent)
! 560:
! 561: { "ReadFile", (SYSCALL)ReadFile, 0 },
! 562:
! 563: #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
! 564: LPOVERLAPPED))aSyscall[50].pCurrent)
! 565:
! 566: { "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 },
! 567:
! 568: #define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[51].pCurrent)
! 569:
! 570: { "SetFilePointer", (SYSCALL)SetFilePointer, 0 },
! 571:
! 572: #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
! 573: DWORD))aSyscall[52].pCurrent)
! 574:
! 575: { "Sleep", (SYSCALL)Sleep, 0 },
! 576:
! 577: #define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[53].pCurrent)
! 578:
! 579: { "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 },
! 580:
! 581: #define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \
! 582: LPFILETIME))aSyscall[54].pCurrent)
! 583:
! 584: #if !SQLITE_OS_WINCE
! 585: { "UnlockFile", (SYSCALL)UnlockFile, 0 },
! 586:
! 587: #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
! 588: DWORD))aSyscall[55].pCurrent)
! 589: #else
! 590: { "UnlockFile", (SYSCALL)0, 0 },
! 591: #endif
! 592:
! 593: #if !SQLITE_OS_WINCE
! 594: { "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 },
! 595:
! 596: #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
! 597: LPOVERLAPPED))aSyscall[56].pCurrent)
! 598: #else
! 599: { "UnlockFileEx", (SYSCALL)0, 0 },
! 600: #endif
! 601:
! 602: { "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 },
! 603:
! 604: #define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[57].pCurrent)
! 605:
! 606: { "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 },
! 607:
! 608: #define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \
! 609: LPCSTR,LPBOOL))aSyscall[58].pCurrent)
! 610:
! 611: { "WriteFile", (SYSCALL)WriteFile, 0 },
! 612:
! 613: #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
! 614: LPOVERLAPPED))aSyscall[59].pCurrent)
! 615:
! 616: }; /* End of the overrideable system calls */
! 617:
! 618: /*
! 619: ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
! 620: ** "win32" VFSes. Return SQLITE_OK opon successfully updating the
! 621: ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
! 622: ** system call named zName.
! 623: */
! 624: static int winSetSystemCall(
! 625: sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
! 626: const char *zName, /* Name of system call to override */
! 627: sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
! 628: ){
! 629: unsigned int i;
! 630: int rc = SQLITE_NOTFOUND;
! 631:
! 632: UNUSED_PARAMETER(pNotUsed);
! 633: if( zName==0 ){
! 634: /* If no zName is given, restore all system calls to their default
! 635: ** settings and return NULL
! 636: */
! 637: rc = SQLITE_OK;
! 638: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
! 639: if( aSyscall[i].pDefault ){
! 640: aSyscall[i].pCurrent = aSyscall[i].pDefault;
! 641: }
! 642: }
! 643: }else{
! 644: /* If zName is specified, operate on only the one system call
! 645: ** specified.
! 646: */
! 647: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
! 648: if( strcmp(zName, aSyscall[i].zName)==0 ){
! 649: if( aSyscall[i].pDefault==0 ){
! 650: aSyscall[i].pDefault = aSyscall[i].pCurrent;
! 651: }
! 652: rc = SQLITE_OK;
! 653: if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
! 654: aSyscall[i].pCurrent = pNewFunc;
! 655: break;
! 656: }
! 657: }
! 658: }
! 659: return rc;
! 660: }
! 661:
! 662: /*
! 663: ** Return the value of a system call. Return NULL if zName is not a
! 664: ** recognized system call name. NULL is also returned if the system call
! 665: ** is currently undefined.
! 666: */
! 667: static sqlite3_syscall_ptr winGetSystemCall(
! 668: sqlite3_vfs *pNotUsed,
! 669: const char *zName
! 670: ){
! 671: unsigned int i;
! 672:
! 673: UNUSED_PARAMETER(pNotUsed);
! 674: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
! 675: if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
! 676: }
! 677: return 0;
! 678: }
! 679:
! 680: /*
! 681: ** Return the name of the first system call after zName. If zName==NULL
! 682: ** then return the name of the first system call. Return NULL if zName
! 683: ** is the last system call or if zName is not the name of a valid
! 684: ** system call.
! 685: */
! 686: static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
! 687: int i = -1;
! 688:
! 689: UNUSED_PARAMETER(p);
! 690: if( zName ){
! 691: for(i=0; i<ArraySize(aSyscall)-1; i++){
! 692: if( strcmp(zName, aSyscall[i].zName)==0 ) break;
! 693: }
! 694: }
! 695: for(i++; i<ArraySize(aSyscall); i++){
! 696: if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
! 697: }
! 698: return 0;
! 699: }
! 700:
! 701: /*
! 702: ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
! 703: ** or WinCE. Return false (zero) for Win95, Win98, or WinME.
! 704: **
! 705: ** Here is an interesting observation: Win95, Win98, and WinME lack
! 706: ** the LockFileEx() API. But we can still statically link against that
! 707: ** API as long as we don't call it when running Win95/98/ME. A call to
! 708: ** this routine is used to determine if the host is Win95/98/ME or
! 709: ** WinNT/2K/XP so that we will know whether or not we can safely call
! 710: ** the LockFileEx() API.
! 711: */
! 712: #if SQLITE_OS_WINCE
! 713: # define isNT() (1)
! 714: #else
! 715: static int isNT(void){
! 716: if( sqlite3_os_type==0 ){
! 717: OSVERSIONINFOA sInfo;
! 718: sInfo.dwOSVersionInfoSize = sizeof(sInfo);
! 719: osGetVersionExA(&sInfo);
! 720: sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
! 721: }
! 722: return sqlite3_os_type==2;
! 723: }
! 724: #endif /* SQLITE_OS_WINCE */
! 725:
! 726: #ifdef SQLITE_WIN32_MALLOC
! 727: /*
! 728: ** Allocate nBytes of memory.
! 729: */
! 730: static void *winMemMalloc(int nBytes){
! 731: HANDLE hHeap;
! 732: void *p;
! 733:
! 734: winMemAssertMagic();
! 735: hHeap = winMemGetHeap();
! 736: assert( hHeap!=0 );
! 737: assert( hHeap!=INVALID_HANDLE_VALUE );
! 738: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 739: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
! 740: #endif
! 741: assert( nBytes>=0 );
! 742: p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
! 743: if( !p ){
! 744: sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%d), heap=%p",
! 745: nBytes, osGetLastError(), (void*)hHeap);
! 746: }
! 747: return p;
! 748: }
! 749:
! 750: /*
! 751: ** Free memory.
! 752: */
! 753: static void winMemFree(void *pPrior){
! 754: HANDLE hHeap;
! 755:
! 756: winMemAssertMagic();
! 757: hHeap = winMemGetHeap();
! 758: assert( hHeap!=0 );
! 759: assert( hHeap!=INVALID_HANDLE_VALUE );
! 760: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 761: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
! 762: #endif
! 763: if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
! 764: if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
! 765: sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%d), heap=%p",
! 766: pPrior, osGetLastError(), (void*)hHeap);
! 767: }
! 768: }
! 769:
! 770: /*
! 771: ** Change the size of an existing memory allocation
! 772: */
! 773: static void *winMemRealloc(void *pPrior, int nBytes){
! 774: HANDLE hHeap;
! 775: void *p;
! 776:
! 777: winMemAssertMagic();
! 778: hHeap = winMemGetHeap();
! 779: assert( hHeap!=0 );
! 780: assert( hHeap!=INVALID_HANDLE_VALUE );
! 781: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 782: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
! 783: #endif
! 784: assert( nBytes>=0 );
! 785: if( !pPrior ){
! 786: p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
! 787: }else{
! 788: p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
! 789: }
! 790: if( !p ){
! 791: sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%d), heap=%p",
! 792: pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
! 793: (void*)hHeap);
! 794: }
! 795: return p;
! 796: }
! 797:
! 798: /*
! 799: ** Return the size of an outstanding allocation, in bytes.
! 800: */
! 801: static int winMemSize(void *p){
! 802: HANDLE hHeap;
! 803: SIZE_T n;
! 804:
! 805: winMemAssertMagic();
! 806: hHeap = winMemGetHeap();
! 807: assert( hHeap!=0 );
! 808: assert( hHeap!=INVALID_HANDLE_VALUE );
! 809: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 810: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
! 811: #endif
! 812: if( !p ) return 0;
! 813: n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p);
! 814: if( n==(SIZE_T)-1 ){
! 815: sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%d), heap=%p",
! 816: p, osGetLastError(), (void*)hHeap);
! 817: return 0;
! 818: }
! 819: return (int)n;
! 820: }
! 821:
! 822: /*
! 823: ** Round up a request size to the next valid allocation size.
! 824: */
! 825: static int winMemRoundup(int n){
! 826: return n;
! 827: }
! 828:
! 829: /*
! 830: ** Initialize this module.
! 831: */
! 832: static int winMemInit(void *pAppData){
! 833: winMemData *pWinMemData = (winMemData *)pAppData;
! 834:
! 835: if( !pWinMemData ) return SQLITE_ERROR;
! 836: assert( pWinMemData->magic==WINMEM_MAGIC );
! 837: if( !pWinMemData->hHeap ){
! 838: pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS,
! 839: SQLITE_WIN32_HEAP_INIT_SIZE,
! 840: SQLITE_WIN32_HEAP_MAX_SIZE);
! 841: if( !pWinMemData->hHeap ){
! 842: sqlite3_log(SQLITE_NOMEM,
! 843: "failed to HeapCreate (%d), flags=%u, initSize=%u, maxSize=%u",
! 844: osGetLastError(), SQLITE_WIN32_HEAP_FLAGS,
! 845: SQLITE_WIN32_HEAP_INIT_SIZE, SQLITE_WIN32_HEAP_MAX_SIZE);
! 846: return SQLITE_NOMEM;
! 847: }
! 848: pWinMemData->bOwned = TRUE;
! 849: }
! 850: assert( pWinMemData->hHeap!=0 );
! 851: assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
! 852: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 853: assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
! 854: #endif
! 855: return SQLITE_OK;
! 856: }
! 857:
! 858: /*
! 859: ** Deinitialize this module.
! 860: */
! 861: static void winMemShutdown(void *pAppData){
! 862: winMemData *pWinMemData = (winMemData *)pAppData;
! 863:
! 864: if( !pWinMemData ) return;
! 865: if( pWinMemData->hHeap ){
! 866: assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
! 867: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
! 868: assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
! 869: #endif
! 870: if( pWinMemData->bOwned ){
! 871: if( !osHeapDestroy(pWinMemData->hHeap) ){
! 872: sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%d), heap=%p",
! 873: osGetLastError(), (void*)pWinMemData->hHeap);
! 874: }
! 875: pWinMemData->bOwned = FALSE;
! 876: }
! 877: pWinMemData->hHeap = NULL;
! 878: }
! 879: }
! 880:
! 881: /*
! 882: ** Populate the low-level memory allocation function pointers in
! 883: ** sqlite3GlobalConfig.m with pointers to the routines in this file. The
! 884: ** arguments specify the block of memory to manage.
! 885: **
! 886: ** This routine is only called by sqlite3_config(), and therefore
! 887: ** is not required to be threadsafe (it is not).
! 888: */
! 889: const sqlite3_mem_methods *sqlite3MemGetWin32(void){
! 890: static const sqlite3_mem_methods winMemMethods = {
! 891: winMemMalloc,
! 892: winMemFree,
! 893: winMemRealloc,
! 894: winMemSize,
! 895: winMemRoundup,
! 896: winMemInit,
! 897: winMemShutdown,
! 898: &win_mem_data
! 899: };
! 900: return &winMemMethods;
! 901: }
! 902:
! 903: void sqlite3MemSetDefault(void){
! 904: sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetWin32());
! 905: }
! 906: #endif /* SQLITE_WIN32_MALLOC */
! 907:
! 908: /*
! 909: ** Convert a UTF-8 string to Microsoft Unicode (UTF-16?).
! 910: **
! 911: ** Space to hold the returned string is obtained from malloc.
! 912: */
! 913: static LPWSTR utf8ToUnicode(const char *zFilename){
! 914: int nChar;
! 915: LPWSTR zWideFilename;
! 916:
! 917: nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
! 918: if( nChar==0 ){
! 919: return 0;
! 920: }
! 921: zWideFilename = sqlite3_malloc( nChar*sizeof(zWideFilename[0]) );
! 922: if( zWideFilename==0 ){
! 923: return 0;
! 924: }
! 925: nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename,
! 926: nChar);
! 927: if( nChar==0 ){
! 928: sqlite3_free(zWideFilename);
! 929: zWideFilename = 0;
! 930: }
! 931: return zWideFilename;
! 932: }
! 933:
! 934: /*
! 935: ** Convert Microsoft Unicode to UTF-8. Space to hold the returned string is
! 936: ** obtained from sqlite3_malloc().
! 937: */
! 938: static char *unicodeToUtf8(LPCWSTR zWideFilename){
! 939: int nByte;
! 940: char *zFilename;
! 941:
! 942: nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
! 943: if( nByte == 0 ){
! 944: return 0;
! 945: }
! 946: zFilename = sqlite3_malloc( nByte );
! 947: if( zFilename==0 ){
! 948: return 0;
! 949: }
! 950: nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
! 951: 0, 0);
! 952: if( nByte == 0 ){
! 953: sqlite3_free(zFilename);
! 954: zFilename = 0;
! 955: }
! 956: return zFilename;
! 957: }
! 958:
! 959: /*
! 960: ** Convert an ANSI string to Microsoft Unicode, based on the
! 961: ** current codepage settings for file apis.
! 962: **
! 963: ** Space to hold the returned string is obtained
! 964: ** from sqlite3_malloc.
! 965: */
! 966: static LPWSTR mbcsToUnicode(const char *zFilename){
! 967: int nByte;
! 968: LPWSTR zMbcsFilename;
! 969: int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP;
! 970:
! 971: nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, NULL,
! 972: 0)*sizeof(WCHAR);
! 973: if( nByte==0 ){
! 974: return 0;
! 975: }
! 976: zMbcsFilename = sqlite3_malloc( nByte*sizeof(zMbcsFilename[0]) );
! 977: if( zMbcsFilename==0 ){
! 978: return 0;
! 979: }
! 980: nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename,
! 981: nByte);
! 982: if( nByte==0 ){
! 983: sqlite3_free(zMbcsFilename);
! 984: zMbcsFilename = 0;
! 985: }
! 986: return zMbcsFilename;
! 987: }
! 988:
! 989: /*
! 990: ** Convert Microsoft Unicode to multi-byte character string, based on the
! 991: ** user's ANSI codepage.
! 992: **
! 993: ** Space to hold the returned string is obtained from
! 994: ** sqlite3_malloc().
! 995: */
! 996: static char *unicodeToMbcs(LPCWSTR zWideFilename){
! 997: int nByte;
! 998: char *zFilename;
! 999: int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP;
! 1000:
! 1001: nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
! 1002: if( nByte == 0 ){
! 1003: return 0;
! 1004: }
! 1005: zFilename = sqlite3_malloc( nByte );
! 1006: if( zFilename==0 ){
! 1007: return 0;
! 1008: }
! 1009: nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename,
! 1010: nByte, 0, 0);
! 1011: if( nByte == 0 ){
! 1012: sqlite3_free(zFilename);
! 1013: zFilename = 0;
! 1014: }
! 1015: return zFilename;
! 1016: }
! 1017:
! 1018: /*
! 1019: ** Convert multibyte character string to UTF-8. Space to hold the
! 1020: ** returned string is obtained from sqlite3_malloc().
! 1021: */
! 1022: char *sqlite3_win32_mbcs_to_utf8(const char *zFilename){
! 1023: char *zFilenameUtf8;
! 1024: LPWSTR zTmpWide;
! 1025:
! 1026: zTmpWide = mbcsToUnicode(zFilename);
! 1027: if( zTmpWide==0 ){
! 1028: return 0;
! 1029: }
! 1030: zFilenameUtf8 = unicodeToUtf8(zTmpWide);
! 1031: sqlite3_free(zTmpWide);
! 1032: return zFilenameUtf8;
! 1033: }
! 1034:
! 1035: /*
! 1036: ** Convert UTF-8 to multibyte character string. Space to hold the
! 1037: ** returned string is obtained from sqlite3_malloc().
! 1038: */
! 1039: char *sqlite3_win32_utf8_to_mbcs(const char *zFilename){
! 1040: char *zFilenameMbcs;
! 1041: LPWSTR zTmpWide;
! 1042:
! 1043: zTmpWide = utf8ToUnicode(zFilename);
! 1044: if( zTmpWide==0 ){
! 1045: return 0;
! 1046: }
! 1047: zFilenameMbcs = unicodeToMbcs(zTmpWide);
! 1048: sqlite3_free(zTmpWide);
! 1049: return zFilenameMbcs;
! 1050: }
! 1051:
! 1052:
! 1053: /*
! 1054: ** The return value of getLastErrorMsg
! 1055: ** is zero if the error message fits in the buffer, or non-zero
! 1056: ** otherwise (if the message was truncated).
! 1057: */
! 1058: static int getLastErrorMsg(DWORD lastErrno, int nBuf, char *zBuf){
! 1059: /* FormatMessage returns 0 on failure. Otherwise it
! 1060: ** returns the number of TCHARs written to the output
! 1061: ** buffer, excluding the terminating null char.
! 1062: */
! 1063: DWORD dwLen = 0;
! 1064: char *zOut = 0;
! 1065:
! 1066: if( isNT() ){
! 1067: LPWSTR zTempWide = NULL;
! 1068: dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
! 1069: FORMAT_MESSAGE_FROM_SYSTEM |
! 1070: FORMAT_MESSAGE_IGNORE_INSERTS,
! 1071: NULL,
! 1072: lastErrno,
! 1073: 0,
! 1074: (LPWSTR) &zTempWide,
! 1075: 0,
! 1076: 0);
! 1077: if( dwLen > 0 ){
! 1078: /* allocate a buffer and convert to UTF8 */
! 1079: sqlite3BeginBenignMalloc();
! 1080: zOut = unicodeToUtf8(zTempWide);
! 1081: sqlite3EndBenignMalloc();
! 1082: /* free the system buffer allocated by FormatMessage */
! 1083: osLocalFree(zTempWide);
! 1084: }
! 1085: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 1086: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 1087: ** it's important to not reference them for WINCE builds.
! 1088: */
! 1089: #if SQLITE_OS_WINCE==0
! 1090: }else{
! 1091: char *zTemp = NULL;
! 1092: dwLen = osFormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
! 1093: FORMAT_MESSAGE_FROM_SYSTEM |
! 1094: FORMAT_MESSAGE_IGNORE_INSERTS,
! 1095: NULL,
! 1096: lastErrno,
! 1097: 0,
! 1098: (LPSTR) &zTemp,
! 1099: 0,
! 1100: 0);
! 1101: if( dwLen > 0 ){
! 1102: /* allocate a buffer and convert to UTF8 */
! 1103: sqlite3BeginBenignMalloc();
! 1104: zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
! 1105: sqlite3EndBenignMalloc();
! 1106: /* free the system buffer allocated by FormatMessage */
! 1107: osLocalFree(zTemp);
! 1108: }
! 1109: #endif
! 1110: }
! 1111: if( 0 == dwLen ){
! 1112: sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", lastErrno, lastErrno);
! 1113: }else{
! 1114: /* copy a maximum of nBuf chars to output buffer */
! 1115: sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
! 1116: /* free the UTF8 buffer */
! 1117: sqlite3_free(zOut);
! 1118: }
! 1119: return 0;
! 1120: }
! 1121:
! 1122: /*
! 1123: **
! 1124: ** This function - winLogErrorAtLine() - is only ever called via the macro
! 1125: ** winLogError().
! 1126: **
! 1127: ** This routine is invoked after an error occurs in an OS function.
! 1128: ** It logs a message using sqlite3_log() containing the current value of
! 1129: ** error code and, if possible, the human-readable equivalent from
! 1130: ** FormatMessage.
! 1131: **
! 1132: ** The first argument passed to the macro should be the error code that
! 1133: ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
! 1134: ** The two subsequent arguments should be the name of the OS function that
! 1135: ** failed and the the associated file-system path, if any.
! 1136: */
! 1137: #define winLogError(a,b,c,d) winLogErrorAtLine(a,b,c,d,__LINE__)
! 1138: static int winLogErrorAtLine(
! 1139: int errcode, /* SQLite error code */
! 1140: DWORD lastErrno, /* Win32 last error */
! 1141: const char *zFunc, /* Name of OS function that failed */
! 1142: const char *zPath, /* File path associated with error */
! 1143: int iLine /* Source line number where error occurred */
! 1144: ){
! 1145: char zMsg[500]; /* Human readable error text */
! 1146: int i; /* Loop counter */
! 1147:
! 1148: zMsg[0] = 0;
! 1149: getLastErrorMsg(lastErrno, sizeof(zMsg), zMsg);
! 1150: assert( errcode!=SQLITE_OK );
! 1151: if( zPath==0 ) zPath = "";
! 1152: for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){}
! 1153: zMsg[i] = 0;
! 1154: sqlite3_log(errcode,
! 1155: "os_win.c:%d: (%d) %s(%s) - %s",
! 1156: iLine, lastErrno, zFunc, zPath, zMsg
! 1157: );
! 1158:
! 1159: return errcode;
! 1160: }
! 1161:
! 1162: /*
! 1163: ** The number of times that a ReadFile(), WriteFile(), and DeleteFile()
! 1164: ** will be retried following a locking error - probably caused by
! 1165: ** antivirus software. Also the initial delay before the first retry.
! 1166: ** The delay increases linearly with each retry.
! 1167: */
! 1168: #ifndef SQLITE_WIN32_IOERR_RETRY
! 1169: # define SQLITE_WIN32_IOERR_RETRY 10
! 1170: #endif
! 1171: #ifndef SQLITE_WIN32_IOERR_RETRY_DELAY
! 1172: # define SQLITE_WIN32_IOERR_RETRY_DELAY 25
! 1173: #endif
! 1174: static int win32IoerrRetry = SQLITE_WIN32_IOERR_RETRY;
! 1175: static int win32IoerrRetryDelay = SQLITE_WIN32_IOERR_RETRY_DELAY;
! 1176:
! 1177: /*
! 1178: ** If a ReadFile() or WriteFile() error occurs, invoke this routine
! 1179: ** to see if it should be retried. Return TRUE to retry. Return FALSE
! 1180: ** to give up with an error.
! 1181: */
! 1182: static int retryIoerr(int *pnRetry, DWORD *pError){
! 1183: DWORD e = osGetLastError();
! 1184: if( *pnRetry>=win32IoerrRetry ){
! 1185: if( pError ){
! 1186: *pError = e;
! 1187: }
! 1188: return 0;
! 1189: }
! 1190: if( e==ERROR_ACCESS_DENIED ||
! 1191: e==ERROR_LOCK_VIOLATION ||
! 1192: e==ERROR_SHARING_VIOLATION ){
! 1193: osSleep(win32IoerrRetryDelay*(1+*pnRetry));
! 1194: ++*pnRetry;
! 1195: return 1;
! 1196: }
! 1197: if( pError ){
! 1198: *pError = e;
! 1199: }
! 1200: return 0;
! 1201: }
! 1202:
! 1203: /*
! 1204: ** Log a I/O error retry episode.
! 1205: */
! 1206: static void logIoerr(int nRetry){
! 1207: if( nRetry ){
! 1208: sqlite3_log(SQLITE_IOERR,
! 1209: "delayed %dms for lock/sharing conflict",
! 1210: win32IoerrRetryDelay*nRetry*(nRetry+1)/2
! 1211: );
! 1212: }
! 1213: }
! 1214:
! 1215: #if SQLITE_OS_WINCE
! 1216: /*************************************************************************
! 1217: ** This section contains code for WinCE only.
! 1218: */
! 1219: /*
! 1220: ** Windows CE does not have a localtime() function. So create a
! 1221: ** substitute.
! 1222: */
! 1223: #include <time.h>
! 1224: struct tm *__cdecl localtime(const time_t *t)
! 1225: {
! 1226: static struct tm y;
! 1227: FILETIME uTm, lTm;
! 1228: SYSTEMTIME pTm;
! 1229: sqlite3_int64 t64;
! 1230: t64 = *t;
! 1231: t64 = (t64 + 11644473600)*10000000;
! 1232: uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
! 1233: uTm.dwHighDateTime= (DWORD)(t64 >> 32);
! 1234: osFileTimeToLocalFileTime(&uTm,&lTm);
! 1235: osFileTimeToSystemTime(&lTm,&pTm);
! 1236: y.tm_year = pTm.wYear - 1900;
! 1237: y.tm_mon = pTm.wMonth - 1;
! 1238: y.tm_wday = pTm.wDayOfWeek;
! 1239: y.tm_mday = pTm.wDay;
! 1240: y.tm_hour = pTm.wHour;
! 1241: y.tm_min = pTm.wMinute;
! 1242: y.tm_sec = pTm.wSecond;
! 1243: return &y;
! 1244: }
! 1245:
! 1246: #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
! 1247:
! 1248: /*
! 1249: ** Acquire a lock on the handle h
! 1250: */
! 1251: static void winceMutexAcquire(HANDLE h){
! 1252: DWORD dwErr;
! 1253: do {
! 1254: dwErr = WaitForSingleObject(h, INFINITE);
! 1255: } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
! 1256: }
! 1257: /*
! 1258: ** Release a lock acquired by winceMutexAcquire()
! 1259: */
! 1260: #define winceMutexRelease(h) ReleaseMutex(h)
! 1261:
! 1262: /*
! 1263: ** Create the mutex and shared memory used for locking in the file
! 1264: ** descriptor pFile
! 1265: */
! 1266: static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
! 1267: LPWSTR zTok;
! 1268: LPWSTR zName;
! 1269: BOOL bInit = TRUE;
! 1270:
! 1271: zName = utf8ToUnicode(zFilename);
! 1272: if( zName==0 ){
! 1273: /* out of memory */
! 1274: return FALSE;
! 1275: }
! 1276:
! 1277: /* Initialize the local lockdata */
! 1278: memset(&pFile->local, 0, sizeof(pFile->local));
! 1279:
! 1280: /* Replace the backslashes from the filename and lowercase it
! 1281: ** to derive a mutex name. */
! 1282: zTok = osCharLowerW(zName);
! 1283: for (;*zTok;zTok++){
! 1284: if (*zTok == '\\') *zTok = '_';
! 1285: }
! 1286:
! 1287: /* Create/open the named mutex */
! 1288: pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
! 1289: if (!pFile->hMutex){
! 1290: pFile->lastErrno = osGetLastError();
! 1291: winLogError(SQLITE_ERROR, pFile->lastErrno, "winceCreateLock1", zFilename);
! 1292: sqlite3_free(zName);
! 1293: return FALSE;
! 1294: }
! 1295:
! 1296: /* Acquire the mutex before continuing */
! 1297: winceMutexAcquire(pFile->hMutex);
! 1298:
! 1299: /* Since the names of named mutexes, semaphores, file mappings etc are
! 1300: ** case-sensitive, take advantage of that by uppercasing the mutex name
! 1301: ** and using that as the shared filemapping name.
! 1302: */
! 1303: osCharUpperW(zName);
! 1304: pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
! 1305: PAGE_READWRITE, 0, sizeof(winceLock),
! 1306: zName);
! 1307:
! 1308: /* Set a flag that indicates we're the first to create the memory so it
! 1309: ** must be zero-initialized */
! 1310: if (osGetLastError() == ERROR_ALREADY_EXISTS){
! 1311: bInit = FALSE;
! 1312: }
! 1313:
! 1314: sqlite3_free(zName);
! 1315:
! 1316: /* If we succeeded in making the shared memory handle, map it. */
! 1317: if (pFile->hShared){
! 1318: pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
! 1319: FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
! 1320: /* If mapping failed, close the shared memory handle and erase it */
! 1321: if (!pFile->shared){
! 1322: pFile->lastErrno = osGetLastError();
! 1323: winLogError(SQLITE_ERROR, pFile->lastErrno,
! 1324: "winceCreateLock2", zFilename);
! 1325: osCloseHandle(pFile->hShared);
! 1326: pFile->hShared = NULL;
! 1327: }
! 1328: }
! 1329:
! 1330: /* If shared memory could not be created, then close the mutex and fail */
! 1331: if (pFile->hShared == NULL){
! 1332: winceMutexRelease(pFile->hMutex);
! 1333: osCloseHandle(pFile->hMutex);
! 1334: pFile->hMutex = NULL;
! 1335: return FALSE;
! 1336: }
! 1337:
! 1338: /* Initialize the shared memory if we're supposed to */
! 1339: if (bInit) {
! 1340: memset(pFile->shared, 0, sizeof(winceLock));
! 1341: }
! 1342:
! 1343: winceMutexRelease(pFile->hMutex);
! 1344: return TRUE;
! 1345: }
! 1346:
! 1347: /*
! 1348: ** Destroy the part of winFile that deals with wince locks
! 1349: */
! 1350: static void winceDestroyLock(winFile *pFile){
! 1351: if (pFile->hMutex){
! 1352: /* Acquire the mutex */
! 1353: winceMutexAcquire(pFile->hMutex);
! 1354:
! 1355: /* The following blocks should probably assert in debug mode, but they
! 1356: are to cleanup in case any locks remained open */
! 1357: if (pFile->local.nReaders){
! 1358: pFile->shared->nReaders --;
! 1359: }
! 1360: if (pFile->local.bReserved){
! 1361: pFile->shared->bReserved = FALSE;
! 1362: }
! 1363: if (pFile->local.bPending){
! 1364: pFile->shared->bPending = FALSE;
! 1365: }
! 1366: if (pFile->local.bExclusive){
! 1367: pFile->shared->bExclusive = FALSE;
! 1368: }
! 1369:
! 1370: /* De-reference and close our copy of the shared memory handle */
! 1371: osUnmapViewOfFile(pFile->shared);
! 1372: osCloseHandle(pFile->hShared);
! 1373:
! 1374: /* Done with the mutex */
! 1375: winceMutexRelease(pFile->hMutex);
! 1376: osCloseHandle(pFile->hMutex);
! 1377: pFile->hMutex = NULL;
! 1378: }
! 1379: }
! 1380:
! 1381: /*
! 1382: ** An implementation of the LockFile() API of Windows for CE
! 1383: */
! 1384: static BOOL winceLockFile(
! 1385: HANDLE *phFile,
! 1386: DWORD dwFileOffsetLow,
! 1387: DWORD dwFileOffsetHigh,
! 1388: DWORD nNumberOfBytesToLockLow,
! 1389: DWORD nNumberOfBytesToLockHigh
! 1390: ){
! 1391: winFile *pFile = HANDLE_TO_WINFILE(phFile);
! 1392: BOOL bReturn = FALSE;
! 1393:
! 1394: UNUSED_PARAMETER(dwFileOffsetHigh);
! 1395: UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
! 1396:
! 1397: if (!pFile->hMutex) return TRUE;
! 1398: winceMutexAcquire(pFile->hMutex);
! 1399:
! 1400: /* Wanting an exclusive lock? */
! 1401: if (dwFileOffsetLow == (DWORD)SHARED_FIRST
! 1402: && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
! 1403: if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
! 1404: pFile->shared->bExclusive = TRUE;
! 1405: pFile->local.bExclusive = TRUE;
! 1406: bReturn = TRUE;
! 1407: }
! 1408: }
! 1409:
! 1410: /* Want a read-only lock? */
! 1411: else if (dwFileOffsetLow == (DWORD)SHARED_FIRST &&
! 1412: nNumberOfBytesToLockLow == 1){
! 1413: if (pFile->shared->bExclusive == 0){
! 1414: pFile->local.nReaders ++;
! 1415: if (pFile->local.nReaders == 1){
! 1416: pFile->shared->nReaders ++;
! 1417: }
! 1418: bReturn = TRUE;
! 1419: }
! 1420: }
! 1421:
! 1422: /* Want a pending lock? */
! 1423: else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToLockLow == 1){
! 1424: /* If no pending lock has been acquired, then acquire it */
! 1425: if (pFile->shared->bPending == 0) {
! 1426: pFile->shared->bPending = TRUE;
! 1427: pFile->local.bPending = TRUE;
! 1428: bReturn = TRUE;
! 1429: }
! 1430: }
! 1431:
! 1432: /* Want a reserved lock? */
! 1433: else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
! 1434: if (pFile->shared->bReserved == 0) {
! 1435: pFile->shared->bReserved = TRUE;
! 1436: pFile->local.bReserved = TRUE;
! 1437: bReturn = TRUE;
! 1438: }
! 1439: }
! 1440:
! 1441: winceMutexRelease(pFile->hMutex);
! 1442: return bReturn;
! 1443: }
! 1444:
! 1445: /*
! 1446: ** An implementation of the UnlockFile API of Windows for CE
! 1447: */
! 1448: static BOOL winceUnlockFile(
! 1449: HANDLE *phFile,
! 1450: DWORD dwFileOffsetLow,
! 1451: DWORD dwFileOffsetHigh,
! 1452: DWORD nNumberOfBytesToUnlockLow,
! 1453: DWORD nNumberOfBytesToUnlockHigh
! 1454: ){
! 1455: winFile *pFile = HANDLE_TO_WINFILE(phFile);
! 1456: BOOL bReturn = FALSE;
! 1457:
! 1458: UNUSED_PARAMETER(dwFileOffsetHigh);
! 1459: UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh);
! 1460:
! 1461: if (!pFile->hMutex) return TRUE;
! 1462: winceMutexAcquire(pFile->hMutex);
! 1463:
! 1464: /* Releasing a reader lock or an exclusive lock */
! 1465: if (dwFileOffsetLow == (DWORD)SHARED_FIRST){
! 1466: /* Did we have an exclusive lock? */
! 1467: if (pFile->local.bExclusive){
! 1468: assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
! 1469: pFile->local.bExclusive = FALSE;
! 1470: pFile->shared->bExclusive = FALSE;
! 1471: bReturn = TRUE;
! 1472: }
! 1473:
! 1474: /* Did we just have a reader lock? */
! 1475: else if (pFile->local.nReaders){
! 1476: assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE || nNumberOfBytesToUnlockLow == 1);
! 1477: pFile->local.nReaders --;
! 1478: if (pFile->local.nReaders == 0)
! 1479: {
! 1480: pFile->shared->nReaders --;
! 1481: }
! 1482: bReturn = TRUE;
! 1483: }
! 1484: }
! 1485:
! 1486: /* Releasing a pending lock */
! 1487: else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
! 1488: if (pFile->local.bPending){
! 1489: pFile->local.bPending = FALSE;
! 1490: pFile->shared->bPending = FALSE;
! 1491: bReturn = TRUE;
! 1492: }
! 1493: }
! 1494: /* Releasing a reserved lock */
! 1495: else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
! 1496: if (pFile->local.bReserved) {
! 1497: pFile->local.bReserved = FALSE;
! 1498: pFile->shared->bReserved = FALSE;
! 1499: bReturn = TRUE;
! 1500: }
! 1501: }
! 1502:
! 1503: winceMutexRelease(pFile->hMutex);
! 1504: return bReturn;
! 1505: }
! 1506:
! 1507: /*
! 1508: ** An implementation of the LockFileEx() API of Windows for CE
! 1509: */
! 1510: static BOOL winceLockFileEx(
! 1511: HANDLE *phFile,
! 1512: DWORD dwFlags,
! 1513: DWORD dwReserved,
! 1514: DWORD nNumberOfBytesToLockLow,
! 1515: DWORD nNumberOfBytesToLockHigh,
! 1516: LPOVERLAPPED lpOverlapped
! 1517: ){
! 1518: UNUSED_PARAMETER(dwReserved);
! 1519: UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
! 1520:
! 1521: /* If the caller wants a shared read lock, forward this call
! 1522: ** to winceLockFile */
! 1523: if (lpOverlapped->Offset == (DWORD)SHARED_FIRST &&
! 1524: dwFlags == 1 &&
! 1525: nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
! 1526: return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
! 1527: }
! 1528: return FALSE;
! 1529: }
! 1530: /*
! 1531: ** End of the special code for wince
! 1532: *****************************************************************************/
! 1533: #endif /* SQLITE_OS_WINCE */
! 1534:
! 1535: /*****************************************************************************
! 1536: ** The next group of routines implement the I/O methods specified
! 1537: ** by the sqlite3_io_methods object.
! 1538: ******************************************************************************/
! 1539:
! 1540: /*
! 1541: ** Some Microsoft compilers lack this definition.
! 1542: */
! 1543: #ifndef INVALID_SET_FILE_POINTER
! 1544: # define INVALID_SET_FILE_POINTER ((DWORD)-1)
! 1545: #endif
! 1546:
! 1547: /*
! 1548: ** Move the current position of the file handle passed as the first
! 1549: ** argument to offset iOffset within the file. If successful, return 0.
! 1550: ** Otherwise, set pFile->lastErrno and return non-zero.
! 1551: */
! 1552: static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
! 1553: LONG upperBits; /* Most sig. 32 bits of new offset */
! 1554: LONG lowerBits; /* Least sig. 32 bits of new offset */
! 1555: DWORD dwRet; /* Value returned by SetFilePointer() */
! 1556: DWORD lastErrno; /* Value returned by GetLastError() */
! 1557:
! 1558: upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
! 1559: lowerBits = (LONG)(iOffset & 0xffffffff);
! 1560:
! 1561: /* API oddity: If successful, SetFilePointer() returns a dword
! 1562: ** containing the lower 32-bits of the new file-offset. Or, if it fails,
! 1563: ** it returns INVALID_SET_FILE_POINTER. However according to MSDN,
! 1564: ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
! 1565: ** whether an error has actually occured, it is also necessary to call
! 1566: ** GetLastError().
! 1567: */
! 1568: dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
! 1569:
! 1570: if( (dwRet==INVALID_SET_FILE_POINTER
! 1571: && ((lastErrno = osGetLastError())!=NO_ERROR)) ){
! 1572: pFile->lastErrno = lastErrno;
! 1573: winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
! 1574: "seekWinFile", pFile->zPath);
! 1575: return 1;
! 1576: }
! 1577:
! 1578: return 0;
! 1579: }
! 1580:
! 1581: /*
! 1582: ** Close a file.
! 1583: **
! 1584: ** It is reported that an attempt to close a handle might sometimes
! 1585: ** fail. This is a very unreasonable result, but Windows is notorious
! 1586: ** for being unreasonable so I do not doubt that it might happen. If
! 1587: ** the close fails, we pause for 100 milliseconds and try again. As
! 1588: ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
! 1589: ** giving up and returning an error.
! 1590: */
! 1591: #define MX_CLOSE_ATTEMPT 3
! 1592: static int winClose(sqlite3_file *id){
! 1593: int rc, cnt = 0;
! 1594: winFile *pFile = (winFile*)id;
! 1595:
! 1596: assert( id!=0 );
! 1597: assert( pFile->pShm==0 );
! 1598: OSTRACE(("CLOSE %d\n", pFile->h));
! 1599: do{
! 1600: rc = osCloseHandle(pFile->h);
! 1601: /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */
! 1602: }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (osSleep(100), 1) );
! 1603: #if SQLITE_OS_WINCE
! 1604: #define WINCE_DELETION_ATTEMPTS 3
! 1605: winceDestroyLock(pFile);
! 1606: if( pFile->zDeleteOnClose ){
! 1607: int cnt = 0;
! 1608: while(
! 1609: osDeleteFileW(pFile->zDeleteOnClose)==0
! 1610: && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
! 1611: && cnt++ < WINCE_DELETION_ATTEMPTS
! 1612: ){
! 1613: osSleep(100); /* Wait a little before trying again */
! 1614: }
! 1615: sqlite3_free(pFile->zDeleteOnClose);
! 1616: }
! 1617: #endif
! 1618: OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
! 1619: OpenCounter(-1);
! 1620: return rc ? SQLITE_OK
! 1621: : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(),
! 1622: "winClose", pFile->zPath);
! 1623: }
! 1624:
! 1625: /*
! 1626: ** Read data from a file into a buffer. Return SQLITE_OK if all
! 1627: ** bytes were read successfully and SQLITE_IOERR if anything goes
! 1628: ** wrong.
! 1629: */
! 1630: static int winRead(
! 1631: sqlite3_file *id, /* File to read from */
! 1632: void *pBuf, /* Write content into this buffer */
! 1633: int amt, /* Number of bytes to read */
! 1634: sqlite3_int64 offset /* Begin reading at this offset */
! 1635: ){
! 1636: winFile *pFile = (winFile*)id; /* file handle */
! 1637: DWORD nRead; /* Number of bytes actually read from file */
! 1638: int nRetry = 0; /* Number of retrys */
! 1639:
! 1640: assert( id!=0 );
! 1641: SimulateIOError(return SQLITE_IOERR_READ);
! 1642: OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
! 1643:
! 1644: if( seekWinFile(pFile, offset) ){
! 1645: return SQLITE_FULL;
! 1646: }
! 1647: while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
! 1648: DWORD lastErrno;
! 1649: if( retryIoerr(&nRetry, &lastErrno) ) continue;
! 1650: pFile->lastErrno = lastErrno;
! 1651: return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
! 1652: "winRead", pFile->zPath);
! 1653: }
! 1654: logIoerr(nRetry);
! 1655: if( nRead<(DWORD)amt ){
! 1656: /* Unread parts of the buffer must be zero-filled */
! 1657: memset(&((char*)pBuf)[nRead], 0, amt-nRead);
! 1658: return SQLITE_IOERR_SHORT_READ;
! 1659: }
! 1660:
! 1661: return SQLITE_OK;
! 1662: }
! 1663:
! 1664: /*
! 1665: ** Write data from a buffer into a file. Return SQLITE_OK on success
! 1666: ** or some other error code on failure.
! 1667: */
! 1668: static int winWrite(
! 1669: sqlite3_file *id, /* File to write into */
! 1670: const void *pBuf, /* The bytes to be written */
! 1671: int amt, /* Number of bytes to write */
! 1672: sqlite3_int64 offset /* Offset into the file to begin writing at */
! 1673: ){
! 1674: int rc; /* True if error has occured, else false */
! 1675: winFile *pFile = (winFile*)id; /* File handle */
! 1676: int nRetry = 0; /* Number of retries */
! 1677:
! 1678: assert( amt>0 );
! 1679: assert( pFile );
! 1680: SimulateIOError(return SQLITE_IOERR_WRITE);
! 1681: SimulateDiskfullError(return SQLITE_FULL);
! 1682:
! 1683: OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
! 1684:
! 1685: rc = seekWinFile(pFile, offset);
! 1686: if( rc==0 ){
! 1687: u8 *aRem = (u8 *)pBuf; /* Data yet to be written */
! 1688: int nRem = amt; /* Number of bytes yet to be written */
! 1689: DWORD nWrite; /* Bytes written by each WriteFile() call */
! 1690: DWORD lastErrno = NO_ERROR; /* Value returned by GetLastError() */
! 1691:
! 1692: while( nRem>0 ){
! 1693: if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
! 1694: if( retryIoerr(&nRetry, &lastErrno) ) continue;
! 1695: break;
! 1696: }
! 1697: if( nWrite<=0 ) break;
! 1698: aRem += nWrite;
! 1699: nRem -= nWrite;
! 1700: }
! 1701: if( nRem>0 ){
! 1702: pFile->lastErrno = lastErrno;
! 1703: rc = 1;
! 1704: }
! 1705: }
! 1706:
! 1707: if( rc ){
! 1708: if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
! 1709: || ( pFile->lastErrno==ERROR_DISK_FULL )){
! 1710: return SQLITE_FULL;
! 1711: }
! 1712: return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
! 1713: "winWrite", pFile->zPath);
! 1714: }else{
! 1715: logIoerr(nRetry);
! 1716: }
! 1717: return SQLITE_OK;
! 1718: }
! 1719:
! 1720: /*
! 1721: ** Truncate an open file to a specified size
! 1722: */
! 1723: static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
! 1724: winFile *pFile = (winFile*)id; /* File handle object */
! 1725: int rc = SQLITE_OK; /* Return code for this function */
! 1726:
! 1727: assert( pFile );
! 1728:
! 1729: OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
! 1730: SimulateIOError(return SQLITE_IOERR_TRUNCATE);
! 1731:
! 1732: /* If the user has configured a chunk-size for this file, truncate the
! 1733: ** file so that it consists of an integer number of chunks (i.e. the
! 1734: ** actual file size after the operation may be larger than the requested
! 1735: ** size).
! 1736: */
! 1737: if( pFile->szChunk>0 ){
! 1738: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
! 1739: }
! 1740:
! 1741: /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
! 1742: if( seekWinFile(pFile, nByte) ){
! 1743: rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
! 1744: "winTruncate1", pFile->zPath);
! 1745: }else if( 0==osSetEndOfFile(pFile->h) ){
! 1746: pFile->lastErrno = osGetLastError();
! 1747: rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
! 1748: "winTruncate2", pFile->zPath);
! 1749: }
! 1750:
! 1751: OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
! 1752: return rc;
! 1753: }
! 1754:
! 1755: #ifdef SQLITE_TEST
! 1756: /*
! 1757: ** Count the number of fullsyncs and normal syncs. This is used to test
! 1758: ** that syncs and fullsyncs are occuring at the right times.
! 1759: */
! 1760: int sqlite3_sync_count = 0;
! 1761: int sqlite3_fullsync_count = 0;
! 1762: #endif
! 1763:
! 1764: /*
! 1765: ** Make sure all writes to a particular file are committed to disk.
! 1766: */
! 1767: static int winSync(sqlite3_file *id, int flags){
! 1768: #ifndef SQLITE_NO_SYNC
! 1769: /*
! 1770: ** Used only when SQLITE_NO_SYNC is not defined.
! 1771: */
! 1772: BOOL rc;
! 1773: #endif
! 1774: #if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \
! 1775: (defined(SQLITE_TEST) && defined(SQLITE_DEBUG))
! 1776: /*
! 1777: ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or
! 1778: ** OSTRACE() macros.
! 1779: */
! 1780: winFile *pFile = (winFile*)id;
! 1781: #else
! 1782: UNUSED_PARAMETER(id);
! 1783: #endif
! 1784:
! 1785: assert( pFile );
! 1786: /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
! 1787: assert((flags&0x0F)==SQLITE_SYNC_NORMAL
! 1788: || (flags&0x0F)==SQLITE_SYNC_FULL
! 1789: );
! 1790:
! 1791: OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
! 1792:
! 1793: /* Unix cannot, but some systems may return SQLITE_FULL from here. This
! 1794: ** line is to test that doing so does not cause any problems.
! 1795: */
! 1796: SimulateDiskfullError( return SQLITE_FULL );
! 1797:
! 1798: #ifndef SQLITE_TEST
! 1799: UNUSED_PARAMETER(flags);
! 1800: #else
! 1801: if( (flags&0x0F)==SQLITE_SYNC_FULL ){
! 1802: sqlite3_fullsync_count++;
! 1803: }
! 1804: sqlite3_sync_count++;
! 1805: #endif
! 1806:
! 1807: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
! 1808: ** no-op
! 1809: */
! 1810: #ifdef SQLITE_NO_SYNC
! 1811: return SQLITE_OK;
! 1812: #else
! 1813: rc = osFlushFileBuffers(pFile->h);
! 1814: SimulateIOError( rc=FALSE );
! 1815: if( rc ){
! 1816: return SQLITE_OK;
! 1817: }else{
! 1818: pFile->lastErrno = osGetLastError();
! 1819: return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
! 1820: "winSync", pFile->zPath);
! 1821: }
! 1822: #endif
! 1823: }
! 1824:
! 1825: /*
! 1826: ** Determine the current size of a file in bytes
! 1827: */
! 1828: static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
! 1829: DWORD upperBits;
! 1830: DWORD lowerBits;
! 1831: winFile *pFile = (winFile*)id;
! 1832: DWORD lastErrno;
! 1833:
! 1834: assert( id!=0 );
! 1835: SimulateIOError(return SQLITE_IOERR_FSTAT);
! 1836: lowerBits = osGetFileSize(pFile->h, &upperBits);
! 1837: if( (lowerBits == INVALID_FILE_SIZE)
! 1838: && ((lastErrno = osGetLastError())!=NO_ERROR) )
! 1839: {
! 1840: pFile->lastErrno = lastErrno;
! 1841: return winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
! 1842: "winFileSize", pFile->zPath);
! 1843: }
! 1844: *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
! 1845: return SQLITE_OK;
! 1846: }
! 1847:
! 1848: /*
! 1849: ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
! 1850: */
! 1851: #ifndef LOCKFILE_FAIL_IMMEDIATELY
! 1852: # define LOCKFILE_FAIL_IMMEDIATELY 1
! 1853: #endif
! 1854:
! 1855: /*
! 1856: ** Acquire a reader lock.
! 1857: ** Different API routines are called depending on whether or not this
! 1858: ** is Win9x or WinNT.
! 1859: */
! 1860: static int getReadLock(winFile *pFile){
! 1861: int res;
! 1862: if( isNT() ){
! 1863: OVERLAPPED ovlp;
! 1864: ovlp.Offset = SHARED_FIRST;
! 1865: ovlp.OffsetHigh = 0;
! 1866: ovlp.hEvent = 0;
! 1867: res = osLockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
! 1868: 0, SHARED_SIZE, 0, &ovlp);
! 1869: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 1870: */
! 1871: #if SQLITE_OS_WINCE==0
! 1872: }else{
! 1873: int lk;
! 1874: sqlite3_randomness(sizeof(lk), &lk);
! 1875: pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
! 1876: res = osLockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
! 1877: #endif
! 1878: }
! 1879: if( res == 0 ){
! 1880: pFile->lastErrno = osGetLastError();
! 1881: /* No need to log a failure to lock */
! 1882: }
! 1883: return res;
! 1884: }
! 1885:
! 1886: /*
! 1887: ** Undo a readlock
! 1888: */
! 1889: static int unlockReadLock(winFile *pFile){
! 1890: int res;
! 1891: DWORD lastErrno;
! 1892: if( isNT() ){
! 1893: res = osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
! 1894: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 1895: */
! 1896: #if SQLITE_OS_WINCE==0
! 1897: }else{
! 1898: res = osUnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
! 1899: #endif
! 1900: }
! 1901: if( res==0 && ((lastErrno = osGetLastError())!=ERROR_NOT_LOCKED) ){
! 1902: pFile->lastErrno = lastErrno;
! 1903: winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
! 1904: "unlockReadLock", pFile->zPath);
! 1905: }
! 1906: return res;
! 1907: }
! 1908:
! 1909: /*
! 1910: ** Lock the file with the lock specified by parameter locktype - one
! 1911: ** of the following:
! 1912: **
! 1913: ** (1) SHARED_LOCK
! 1914: ** (2) RESERVED_LOCK
! 1915: ** (3) PENDING_LOCK
! 1916: ** (4) EXCLUSIVE_LOCK
! 1917: **
! 1918: ** Sometimes when requesting one lock state, additional lock states
! 1919: ** are inserted in between. The locking might fail on one of the later
! 1920: ** transitions leaving the lock state different from what it started but
! 1921: ** still short of its goal. The following chart shows the allowed
! 1922: ** transitions and the inserted intermediate states:
! 1923: **
! 1924: ** UNLOCKED -> SHARED
! 1925: ** SHARED -> RESERVED
! 1926: ** SHARED -> (PENDING) -> EXCLUSIVE
! 1927: ** RESERVED -> (PENDING) -> EXCLUSIVE
! 1928: ** PENDING -> EXCLUSIVE
! 1929: **
! 1930: ** This routine will only increase a lock. The winUnlock() routine
! 1931: ** erases all locks at once and returns us immediately to locking level 0.
! 1932: ** It is not possible to lower the locking level one step at a time. You
! 1933: ** must go straight to locking level 0.
! 1934: */
! 1935: static int winLock(sqlite3_file *id, int locktype){
! 1936: int rc = SQLITE_OK; /* Return code from subroutines */
! 1937: int res = 1; /* Result of a Windows lock call */
! 1938: int newLocktype; /* Set pFile->locktype to this value before exiting */
! 1939: int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
! 1940: winFile *pFile = (winFile*)id;
! 1941: DWORD lastErrno = NO_ERROR;
! 1942:
! 1943: assert( id!=0 );
! 1944: OSTRACE(("LOCK %d %d was %d(%d)\n",
! 1945: pFile->h, locktype, pFile->locktype, pFile->sharedLockByte));
! 1946:
! 1947: /* If there is already a lock of this type or more restrictive on the
! 1948: ** OsFile, do nothing. Don't use the end_lock: exit path, as
! 1949: ** sqlite3OsEnterMutex() hasn't been called yet.
! 1950: */
! 1951: if( pFile->locktype>=locktype ){
! 1952: return SQLITE_OK;
! 1953: }
! 1954:
! 1955: /* Make sure the locking sequence is correct
! 1956: */
! 1957: assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
! 1958: assert( locktype!=PENDING_LOCK );
! 1959: assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
! 1960:
! 1961: /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
! 1962: ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
! 1963: ** the PENDING_LOCK byte is temporary.
! 1964: */
! 1965: newLocktype = pFile->locktype;
! 1966: if( (pFile->locktype==NO_LOCK)
! 1967: || ( (locktype==EXCLUSIVE_LOCK)
! 1968: && (pFile->locktype==RESERVED_LOCK))
! 1969: ){
! 1970: int cnt = 3;
! 1971: while( cnt-->0 && (res = osLockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
! 1972: /* Try 3 times to get the pending lock. This is needed to work
! 1973: ** around problems caused by indexing and/or anti-virus software on
! 1974: ** Windows systems.
! 1975: ** If you are using this code as a model for alternative VFSes, do not
! 1976: ** copy this retry logic. It is a hack intended for Windows only.
! 1977: */
! 1978: OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
! 1979: if( cnt ) osSleep(1);
! 1980: }
! 1981: gotPendingLock = res;
! 1982: if( !res ){
! 1983: lastErrno = osGetLastError();
! 1984: }
! 1985: }
! 1986:
! 1987: /* Acquire a shared lock
! 1988: */
! 1989: if( locktype==SHARED_LOCK && res ){
! 1990: assert( pFile->locktype==NO_LOCK );
! 1991: res = getReadLock(pFile);
! 1992: if( res ){
! 1993: newLocktype = SHARED_LOCK;
! 1994: }else{
! 1995: lastErrno = osGetLastError();
! 1996: }
! 1997: }
! 1998:
! 1999: /* Acquire a RESERVED lock
! 2000: */
! 2001: if( locktype==RESERVED_LOCK && res ){
! 2002: assert( pFile->locktype==SHARED_LOCK );
! 2003: res = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
! 2004: if( res ){
! 2005: newLocktype = RESERVED_LOCK;
! 2006: }else{
! 2007: lastErrno = osGetLastError();
! 2008: }
! 2009: }
! 2010:
! 2011: /* Acquire a PENDING lock
! 2012: */
! 2013: if( locktype==EXCLUSIVE_LOCK && res ){
! 2014: newLocktype = PENDING_LOCK;
! 2015: gotPendingLock = 0;
! 2016: }
! 2017:
! 2018: /* Acquire an EXCLUSIVE lock
! 2019: */
! 2020: if( locktype==EXCLUSIVE_LOCK && res ){
! 2021: assert( pFile->locktype>=SHARED_LOCK );
! 2022: res = unlockReadLock(pFile);
! 2023: OSTRACE(("unreadlock = %d\n", res));
! 2024: res = osLockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
! 2025: if( res ){
! 2026: newLocktype = EXCLUSIVE_LOCK;
! 2027: }else{
! 2028: lastErrno = osGetLastError();
! 2029: OSTRACE(("error-code = %d\n", lastErrno));
! 2030: getReadLock(pFile);
! 2031: }
! 2032: }
! 2033:
! 2034: /* If we are holding a PENDING lock that ought to be released, then
! 2035: ** release it now.
! 2036: */
! 2037: if( gotPendingLock && locktype==SHARED_LOCK ){
! 2038: osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
! 2039: }
! 2040:
! 2041: /* Update the state of the lock has held in the file descriptor then
! 2042: ** return the appropriate result code.
! 2043: */
! 2044: if( res ){
! 2045: rc = SQLITE_OK;
! 2046: }else{
! 2047: OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
! 2048: locktype, newLocktype));
! 2049: pFile->lastErrno = lastErrno;
! 2050: rc = SQLITE_BUSY;
! 2051: }
! 2052: pFile->locktype = (u8)newLocktype;
! 2053: return rc;
! 2054: }
! 2055:
! 2056: /*
! 2057: ** This routine checks if there is a RESERVED lock held on the specified
! 2058: ** file by this or any other process. If such a lock is held, return
! 2059: ** non-zero, otherwise zero.
! 2060: */
! 2061: static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
! 2062: int rc;
! 2063: winFile *pFile = (winFile*)id;
! 2064:
! 2065: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
! 2066:
! 2067: assert( id!=0 );
! 2068: if( pFile->locktype>=RESERVED_LOCK ){
! 2069: rc = 1;
! 2070: OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc));
! 2071: }else{
! 2072: rc = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
! 2073: if( rc ){
! 2074: osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
! 2075: }
! 2076: rc = !rc;
! 2077: OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc));
! 2078: }
! 2079: *pResOut = rc;
! 2080: return SQLITE_OK;
! 2081: }
! 2082:
! 2083: /*
! 2084: ** Lower the locking level on file descriptor id to locktype. locktype
! 2085: ** must be either NO_LOCK or SHARED_LOCK.
! 2086: **
! 2087: ** If the locking level of the file descriptor is already at or below
! 2088: ** the requested locking level, this routine is a no-op.
! 2089: **
! 2090: ** It is not possible for this routine to fail if the second argument
! 2091: ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
! 2092: ** might return SQLITE_IOERR;
! 2093: */
! 2094: static int winUnlock(sqlite3_file *id, int locktype){
! 2095: int type;
! 2096: winFile *pFile = (winFile*)id;
! 2097: int rc = SQLITE_OK;
! 2098: assert( pFile!=0 );
! 2099: assert( locktype<=SHARED_LOCK );
! 2100: OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
! 2101: pFile->locktype, pFile->sharedLockByte));
! 2102: type = pFile->locktype;
! 2103: if( type>=EXCLUSIVE_LOCK ){
! 2104: osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
! 2105: if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
! 2106: /* This should never happen. We should always be able to
! 2107: ** reacquire the read lock */
! 2108: rc = winLogError(SQLITE_IOERR_UNLOCK, osGetLastError(),
! 2109: "winUnlock", pFile->zPath);
! 2110: }
! 2111: }
! 2112: if( type>=RESERVED_LOCK ){
! 2113: osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
! 2114: }
! 2115: if( locktype==NO_LOCK && type>=SHARED_LOCK ){
! 2116: unlockReadLock(pFile);
! 2117: }
! 2118: if( type>=PENDING_LOCK ){
! 2119: osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
! 2120: }
! 2121: pFile->locktype = (u8)locktype;
! 2122: return rc;
! 2123: }
! 2124:
! 2125: /*
! 2126: ** If *pArg is inititially negative then this is a query. Set *pArg to
! 2127: ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
! 2128: **
! 2129: ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
! 2130: */
! 2131: static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
! 2132: if( *pArg<0 ){
! 2133: *pArg = (pFile->ctrlFlags & mask)!=0;
! 2134: }else if( (*pArg)==0 ){
! 2135: pFile->ctrlFlags &= ~mask;
! 2136: }else{
! 2137: pFile->ctrlFlags |= mask;
! 2138: }
! 2139: }
! 2140:
! 2141: /*
! 2142: ** Control and query of the open file handle.
! 2143: */
! 2144: static int winFileControl(sqlite3_file *id, int op, void *pArg){
! 2145: winFile *pFile = (winFile*)id;
! 2146: switch( op ){
! 2147: case SQLITE_FCNTL_LOCKSTATE: {
! 2148: *(int*)pArg = pFile->locktype;
! 2149: return SQLITE_OK;
! 2150: }
! 2151: case SQLITE_LAST_ERRNO: {
! 2152: *(int*)pArg = (int)pFile->lastErrno;
! 2153: return SQLITE_OK;
! 2154: }
! 2155: case SQLITE_FCNTL_CHUNK_SIZE: {
! 2156: pFile->szChunk = *(int *)pArg;
! 2157: return SQLITE_OK;
! 2158: }
! 2159: case SQLITE_FCNTL_SIZE_HINT: {
! 2160: if( pFile->szChunk>0 ){
! 2161: sqlite3_int64 oldSz;
! 2162: int rc = winFileSize(id, &oldSz);
! 2163: if( rc==SQLITE_OK ){
! 2164: sqlite3_int64 newSz = *(sqlite3_int64*)pArg;
! 2165: if( newSz>oldSz ){
! 2166: SimulateIOErrorBenign(1);
! 2167: rc = winTruncate(id, newSz);
! 2168: SimulateIOErrorBenign(0);
! 2169: }
! 2170: }
! 2171: return rc;
! 2172: }
! 2173: return SQLITE_OK;
! 2174: }
! 2175: case SQLITE_FCNTL_PERSIST_WAL: {
! 2176: winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
! 2177: return SQLITE_OK;
! 2178: }
! 2179: case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
! 2180: winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
! 2181: return SQLITE_OK;
! 2182: }
! 2183: case SQLITE_FCNTL_VFSNAME: {
! 2184: *(char**)pArg = sqlite3_mprintf("win32");
! 2185: return SQLITE_OK;
! 2186: }
! 2187: case SQLITE_FCNTL_WIN32_AV_RETRY: {
! 2188: int *a = (int*)pArg;
! 2189: if( a[0]>0 ){
! 2190: win32IoerrRetry = a[0];
! 2191: }else{
! 2192: a[0] = win32IoerrRetry;
! 2193: }
! 2194: if( a[1]>0 ){
! 2195: win32IoerrRetryDelay = a[1];
! 2196: }else{
! 2197: a[1] = win32IoerrRetryDelay;
! 2198: }
! 2199: return SQLITE_OK;
! 2200: }
! 2201: }
! 2202: return SQLITE_NOTFOUND;
! 2203: }
! 2204:
! 2205: /*
! 2206: ** Return the sector size in bytes of the underlying block device for
! 2207: ** the specified file. This is almost always 512 bytes, but may be
! 2208: ** larger for some devices.
! 2209: **
! 2210: ** SQLite code assumes this function cannot fail. It also assumes that
! 2211: ** if two files are created in the same file-system directory (i.e.
! 2212: ** a database and its journal file) that the sector size will be the
! 2213: ** same for both.
! 2214: */
! 2215: static int winSectorSize(sqlite3_file *id){
! 2216: (void)id;
! 2217: return SQLITE_DEFAULT_SECTOR_SIZE;
! 2218: }
! 2219:
! 2220: /*
! 2221: ** Return a vector of device characteristics.
! 2222: */
! 2223: static int winDeviceCharacteristics(sqlite3_file *id){
! 2224: winFile *p = (winFile*)id;
! 2225: return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |
! 2226: ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
! 2227: }
! 2228:
! 2229: #ifndef SQLITE_OMIT_WAL
! 2230:
! 2231: /*
! 2232: ** Windows will only let you create file view mappings
! 2233: ** on allocation size granularity boundaries.
! 2234: ** During sqlite3_os_init() we do a GetSystemInfo()
! 2235: ** to get the granularity size.
! 2236: */
! 2237: SYSTEM_INFO winSysInfo;
! 2238:
! 2239: /*
! 2240: ** Helper functions to obtain and relinquish the global mutex. The
! 2241: ** global mutex is used to protect the winLockInfo objects used by
! 2242: ** this file, all of which may be shared by multiple threads.
! 2243: **
! 2244: ** Function winShmMutexHeld() is used to assert() that the global mutex
! 2245: ** is held when required. This function is only used as part of assert()
! 2246: ** statements. e.g.
! 2247: **
! 2248: ** winShmEnterMutex()
! 2249: ** assert( winShmMutexHeld() );
! 2250: ** winShmLeaveMutex()
! 2251: */
! 2252: static void winShmEnterMutex(void){
! 2253: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 2254: }
! 2255: static void winShmLeaveMutex(void){
! 2256: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 2257: }
! 2258: #ifdef SQLITE_DEBUG
! 2259: static int winShmMutexHeld(void) {
! 2260: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
! 2261: }
! 2262: #endif
! 2263:
! 2264: /*
! 2265: ** Object used to represent a single file opened and mmapped to provide
! 2266: ** shared memory. When multiple threads all reference the same
! 2267: ** log-summary, each thread has its own winFile object, but they all
! 2268: ** point to a single instance of this object. In other words, each
! 2269: ** log-summary is opened only once per process.
! 2270: **
! 2271: ** winShmMutexHeld() must be true when creating or destroying
! 2272: ** this object or while reading or writing the following fields:
! 2273: **
! 2274: ** nRef
! 2275: ** pNext
! 2276: **
! 2277: ** The following fields are read-only after the object is created:
! 2278: **
! 2279: ** fid
! 2280: ** zFilename
! 2281: **
! 2282: ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
! 2283: ** winShmMutexHeld() is true when reading or writing any other field
! 2284: ** in this structure.
! 2285: **
! 2286: */
! 2287: struct winShmNode {
! 2288: sqlite3_mutex *mutex; /* Mutex to access this object */
! 2289: char *zFilename; /* Name of the file */
! 2290: winFile hFile; /* File handle from winOpen */
! 2291:
! 2292: int szRegion; /* Size of shared-memory regions */
! 2293: int nRegion; /* Size of array apRegion */
! 2294: struct ShmRegion {
! 2295: HANDLE hMap; /* File handle from CreateFileMapping */
! 2296: void *pMap;
! 2297: } *aRegion;
! 2298: DWORD lastErrno; /* The Windows errno from the last I/O error */
! 2299:
! 2300: int nRef; /* Number of winShm objects pointing to this */
! 2301: winShm *pFirst; /* All winShm objects pointing to this */
! 2302: winShmNode *pNext; /* Next in list of all winShmNode objects */
! 2303: #ifdef SQLITE_DEBUG
! 2304: u8 nextShmId; /* Next available winShm.id value */
! 2305: #endif
! 2306: };
! 2307:
! 2308: /*
! 2309: ** A global array of all winShmNode objects.
! 2310: **
! 2311: ** The winShmMutexHeld() must be true while reading or writing this list.
! 2312: */
! 2313: static winShmNode *winShmNodeList = 0;
! 2314:
! 2315: /*
! 2316: ** Structure used internally by this VFS to record the state of an
! 2317: ** open shared memory connection.
! 2318: **
! 2319: ** The following fields are initialized when this object is created and
! 2320: ** are read-only thereafter:
! 2321: **
! 2322: ** winShm.pShmNode
! 2323: ** winShm.id
! 2324: **
! 2325: ** All other fields are read/write. The winShm.pShmNode->mutex must be held
! 2326: ** while accessing any read/write fields.
! 2327: */
! 2328: struct winShm {
! 2329: winShmNode *pShmNode; /* The underlying winShmNode object */
! 2330: winShm *pNext; /* Next winShm with the same winShmNode */
! 2331: u8 hasMutex; /* True if holding the winShmNode mutex */
! 2332: u16 sharedMask; /* Mask of shared locks held */
! 2333: u16 exclMask; /* Mask of exclusive locks held */
! 2334: #ifdef SQLITE_DEBUG
! 2335: u8 id; /* Id of this connection with its winShmNode */
! 2336: #endif
! 2337: };
! 2338:
! 2339: /*
! 2340: ** Constants used for locking
! 2341: */
! 2342: #define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
! 2343: #define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
! 2344:
! 2345: /*
! 2346: ** Apply advisory locks for all n bytes beginning at ofst.
! 2347: */
! 2348: #define _SHM_UNLCK 1
! 2349: #define _SHM_RDLCK 2
! 2350: #define _SHM_WRLCK 3
! 2351: static int winShmSystemLock(
! 2352: winShmNode *pFile, /* Apply locks to this open shared-memory segment */
! 2353: int lockType, /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */
! 2354: int ofst, /* Offset to first byte to be locked/unlocked */
! 2355: int nByte /* Number of bytes to lock or unlock */
! 2356: ){
! 2357: OVERLAPPED ovlp;
! 2358: DWORD dwFlags;
! 2359: int rc = 0; /* Result code form Lock/UnlockFileEx() */
! 2360:
! 2361: /* Access to the winShmNode object is serialized by the caller */
! 2362: assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
! 2363:
! 2364: /* Initialize the locking parameters */
! 2365: dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
! 2366: if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
! 2367:
! 2368: memset(&ovlp, 0, sizeof(OVERLAPPED));
! 2369: ovlp.Offset = ofst;
! 2370:
! 2371: /* Release/Acquire the system-level lock */
! 2372: if( lockType==_SHM_UNLCK ){
! 2373: rc = osUnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
! 2374: }else{
! 2375: rc = osLockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
! 2376: }
! 2377:
! 2378: if( rc!= 0 ){
! 2379: rc = SQLITE_OK;
! 2380: }else{
! 2381: pFile->lastErrno = osGetLastError();
! 2382: rc = SQLITE_BUSY;
! 2383: }
! 2384:
! 2385: OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
! 2386: pFile->hFile.h,
! 2387: rc==SQLITE_OK ? "ok" : "failed",
! 2388: lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
! 2389: pFile->lastErrno));
! 2390:
! 2391: return rc;
! 2392: }
! 2393:
! 2394: /* Forward references to VFS methods */
! 2395: static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*);
! 2396: static int winDelete(sqlite3_vfs *,const char*,int);
! 2397:
! 2398: /*
! 2399: ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
! 2400: **
! 2401: ** This is not a VFS shared-memory method; it is a utility function called
! 2402: ** by VFS shared-memory methods.
! 2403: */
! 2404: static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
! 2405: winShmNode **pp;
! 2406: winShmNode *p;
! 2407: BOOL bRc;
! 2408: assert( winShmMutexHeld() );
! 2409: pp = &winShmNodeList;
! 2410: while( (p = *pp)!=0 ){
! 2411: if( p->nRef==0 ){
! 2412: int i;
! 2413: if( p->mutex ) sqlite3_mutex_free(p->mutex);
! 2414: for(i=0; i<p->nRegion; i++){
! 2415: bRc = osUnmapViewOfFile(p->aRegion[i].pMap);
! 2416: OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
! 2417: (int)osGetCurrentProcessId(), i,
! 2418: bRc ? "ok" : "failed"));
! 2419: bRc = osCloseHandle(p->aRegion[i].hMap);
! 2420: OSTRACE(("SHM-PURGE pid-%d close region=%d %s\n",
! 2421: (int)osGetCurrentProcessId(), i,
! 2422: bRc ? "ok" : "failed"));
! 2423: }
! 2424: if( p->hFile.h != INVALID_HANDLE_VALUE ){
! 2425: SimulateIOErrorBenign(1);
! 2426: winClose((sqlite3_file *)&p->hFile);
! 2427: SimulateIOErrorBenign(0);
! 2428: }
! 2429: if( deleteFlag ){
! 2430: SimulateIOErrorBenign(1);
! 2431: sqlite3BeginBenignMalloc();
! 2432: winDelete(pVfs, p->zFilename, 0);
! 2433: sqlite3EndBenignMalloc();
! 2434: SimulateIOErrorBenign(0);
! 2435: }
! 2436: *pp = p->pNext;
! 2437: sqlite3_free(p->aRegion);
! 2438: sqlite3_free(p);
! 2439: }else{
! 2440: pp = &p->pNext;
! 2441: }
! 2442: }
! 2443: }
! 2444:
! 2445: /*
! 2446: ** Open the shared-memory area associated with database file pDbFd.
! 2447: **
! 2448: ** When opening a new shared-memory file, if no other instances of that
! 2449: ** file are currently open, in this process or in other processes, then
! 2450: ** the file must be truncated to zero length or have its header cleared.
! 2451: */
! 2452: static int winOpenSharedMemory(winFile *pDbFd){
! 2453: struct winShm *p; /* The connection to be opened */
! 2454: struct winShmNode *pShmNode = 0; /* The underlying mmapped file */
! 2455: int rc; /* Result code */
! 2456: struct winShmNode *pNew; /* Newly allocated winShmNode */
! 2457: int nName; /* Size of zName in bytes */
! 2458:
! 2459: assert( pDbFd->pShm==0 ); /* Not previously opened */
! 2460:
! 2461: /* Allocate space for the new sqlite3_shm object. Also speculatively
! 2462: ** allocate space for a new winShmNode and filename.
! 2463: */
! 2464: p = sqlite3_malloc( sizeof(*p) );
! 2465: if( p==0 ) return SQLITE_IOERR_NOMEM;
! 2466: memset(p, 0, sizeof(*p));
! 2467: nName = sqlite3Strlen30(pDbFd->zPath);
! 2468: pNew = sqlite3_malloc( sizeof(*pShmNode) + nName + 17 );
! 2469: if( pNew==0 ){
! 2470: sqlite3_free(p);
! 2471: return SQLITE_IOERR_NOMEM;
! 2472: }
! 2473: memset(pNew, 0, sizeof(*pNew) + nName + 17);
! 2474: pNew->zFilename = (char*)&pNew[1];
! 2475: sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
! 2476: sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
! 2477:
! 2478: /* Look to see if there is an existing winShmNode that can be used.
! 2479: ** If no matching winShmNode currently exists, create a new one.
! 2480: */
! 2481: winShmEnterMutex();
! 2482: for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
! 2483: /* TBD need to come up with better match here. Perhaps
! 2484: ** use FILE_ID_BOTH_DIR_INFO Structure.
! 2485: */
! 2486: if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
! 2487: }
! 2488: if( pShmNode ){
! 2489: sqlite3_free(pNew);
! 2490: }else{
! 2491: pShmNode = pNew;
! 2492: pNew = 0;
! 2493: ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
! 2494: pShmNode->pNext = winShmNodeList;
! 2495: winShmNodeList = pShmNode;
! 2496:
! 2497: pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
! 2498: if( pShmNode->mutex==0 ){
! 2499: rc = SQLITE_IOERR_NOMEM;
! 2500: goto shm_open_err;
! 2501: }
! 2502:
! 2503: rc = winOpen(pDbFd->pVfs,
! 2504: pShmNode->zFilename, /* Name of the file (UTF-8) */
! 2505: (sqlite3_file*)&pShmNode->hFile, /* File handle here */
! 2506: SQLITE_OPEN_WAL | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, /* Mode flags */
! 2507: 0);
! 2508: if( SQLITE_OK!=rc ){
! 2509: goto shm_open_err;
! 2510: }
! 2511:
! 2512: /* Check to see if another process is holding the dead-man switch.
! 2513: ** If not, truncate the file to zero length.
! 2514: */
! 2515: if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
! 2516: rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0);
! 2517: if( rc!=SQLITE_OK ){
! 2518: rc = winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(),
! 2519: "winOpenShm", pDbFd->zPath);
! 2520: }
! 2521: }
! 2522: if( rc==SQLITE_OK ){
! 2523: winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
! 2524: rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
! 2525: }
! 2526: if( rc ) goto shm_open_err;
! 2527: }
! 2528:
! 2529: /* Make the new connection a child of the winShmNode */
! 2530: p->pShmNode = pShmNode;
! 2531: #ifdef SQLITE_DEBUG
! 2532: p->id = pShmNode->nextShmId++;
! 2533: #endif
! 2534: pShmNode->nRef++;
! 2535: pDbFd->pShm = p;
! 2536: winShmLeaveMutex();
! 2537:
! 2538: /* The reference count on pShmNode has already been incremented under
! 2539: ** the cover of the winShmEnterMutex() mutex and the pointer from the
! 2540: ** new (struct winShm) object to the pShmNode has been set. All that is
! 2541: ** left to do is to link the new object into the linked list starting
! 2542: ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
! 2543: ** mutex.
! 2544: */
! 2545: sqlite3_mutex_enter(pShmNode->mutex);
! 2546: p->pNext = pShmNode->pFirst;
! 2547: pShmNode->pFirst = p;
! 2548: sqlite3_mutex_leave(pShmNode->mutex);
! 2549: return SQLITE_OK;
! 2550:
! 2551: /* Jump here on any error */
! 2552: shm_open_err:
! 2553: winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
! 2554: winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */
! 2555: sqlite3_free(p);
! 2556: sqlite3_free(pNew);
! 2557: winShmLeaveMutex();
! 2558: return rc;
! 2559: }
! 2560:
! 2561: /*
! 2562: ** Close a connection to shared-memory. Delete the underlying
! 2563: ** storage if deleteFlag is true.
! 2564: */
! 2565: static int winShmUnmap(
! 2566: sqlite3_file *fd, /* Database holding shared memory */
! 2567: int deleteFlag /* Delete after closing if true */
! 2568: ){
! 2569: winFile *pDbFd; /* Database holding shared-memory */
! 2570: winShm *p; /* The connection to be closed */
! 2571: winShmNode *pShmNode; /* The underlying shared-memory file */
! 2572: winShm **pp; /* For looping over sibling connections */
! 2573:
! 2574: pDbFd = (winFile*)fd;
! 2575: p = pDbFd->pShm;
! 2576: if( p==0 ) return SQLITE_OK;
! 2577: pShmNode = p->pShmNode;
! 2578:
! 2579: /* Remove connection p from the set of connections associated
! 2580: ** with pShmNode */
! 2581: sqlite3_mutex_enter(pShmNode->mutex);
! 2582: for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
! 2583: *pp = p->pNext;
! 2584:
! 2585: /* Free the connection p */
! 2586: sqlite3_free(p);
! 2587: pDbFd->pShm = 0;
! 2588: sqlite3_mutex_leave(pShmNode->mutex);
! 2589:
! 2590: /* If pShmNode->nRef has reached 0, then close the underlying
! 2591: ** shared-memory file, too */
! 2592: winShmEnterMutex();
! 2593: assert( pShmNode->nRef>0 );
! 2594: pShmNode->nRef--;
! 2595: if( pShmNode->nRef==0 ){
! 2596: winShmPurge(pDbFd->pVfs, deleteFlag);
! 2597: }
! 2598: winShmLeaveMutex();
! 2599:
! 2600: return SQLITE_OK;
! 2601: }
! 2602:
! 2603: /*
! 2604: ** Change the lock state for a shared-memory segment.
! 2605: */
! 2606: static int winShmLock(
! 2607: sqlite3_file *fd, /* Database file holding the shared memory */
! 2608: int ofst, /* First lock to acquire or release */
! 2609: int n, /* Number of locks to acquire or release */
! 2610: int flags /* What to do with the lock */
! 2611: ){
! 2612: winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */
! 2613: winShm *p = pDbFd->pShm; /* The shared memory being locked */
! 2614: winShm *pX; /* For looping over all siblings */
! 2615: winShmNode *pShmNode = p->pShmNode;
! 2616: int rc = SQLITE_OK; /* Result code */
! 2617: u16 mask; /* Mask of locks to take or release */
! 2618:
! 2619: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
! 2620: assert( n>=1 );
! 2621: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
! 2622: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
! 2623: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
! 2624: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
! 2625: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
! 2626:
! 2627: mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
! 2628: assert( n>1 || mask==(1<<ofst) );
! 2629: sqlite3_mutex_enter(pShmNode->mutex);
! 2630: if( flags & SQLITE_SHM_UNLOCK ){
! 2631: u16 allMask = 0; /* Mask of locks held by siblings */
! 2632:
! 2633: /* See if any siblings hold this same lock */
! 2634: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 2635: if( pX==p ) continue;
! 2636: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
! 2637: allMask |= pX->sharedMask;
! 2638: }
! 2639:
! 2640: /* Unlock the system-level locks */
! 2641: if( (mask & allMask)==0 ){
! 2642: rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
! 2643: }else{
! 2644: rc = SQLITE_OK;
! 2645: }
! 2646:
! 2647: /* Undo the local locks */
! 2648: if( rc==SQLITE_OK ){
! 2649: p->exclMask &= ~mask;
! 2650: p->sharedMask &= ~mask;
! 2651: }
! 2652: }else if( flags & SQLITE_SHM_SHARED ){
! 2653: u16 allShared = 0; /* Union of locks held by connections other than "p" */
! 2654:
! 2655: /* Find out which shared locks are already held by sibling connections.
! 2656: ** If any sibling already holds an exclusive lock, go ahead and return
! 2657: ** SQLITE_BUSY.
! 2658: */
! 2659: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 2660: if( (pX->exclMask & mask)!=0 ){
! 2661: rc = SQLITE_BUSY;
! 2662: break;
! 2663: }
! 2664: allShared |= pX->sharedMask;
! 2665: }
! 2666:
! 2667: /* Get shared locks at the system level, if necessary */
! 2668: if( rc==SQLITE_OK ){
! 2669: if( (allShared & mask)==0 ){
! 2670: rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
! 2671: }else{
! 2672: rc = SQLITE_OK;
! 2673: }
! 2674: }
! 2675:
! 2676: /* Get the local shared locks */
! 2677: if( rc==SQLITE_OK ){
! 2678: p->sharedMask |= mask;
! 2679: }
! 2680: }else{
! 2681: /* Make sure no sibling connections hold locks that will block this
! 2682: ** lock. If any do, return SQLITE_BUSY right away.
! 2683: */
! 2684: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
! 2685: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
! 2686: rc = SQLITE_BUSY;
! 2687: break;
! 2688: }
! 2689: }
! 2690:
! 2691: /* Get the exclusive locks at the system level. Then if successful
! 2692: ** also mark the local connection as being locked.
! 2693: */
! 2694: if( rc==SQLITE_OK ){
! 2695: rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
! 2696: if( rc==SQLITE_OK ){
! 2697: assert( (p->sharedMask & mask)==0 );
! 2698: p->exclMask |= mask;
! 2699: }
! 2700: }
! 2701: }
! 2702: sqlite3_mutex_leave(pShmNode->mutex);
! 2703: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
! 2704: p->id, (int)osGetCurrentProcessId(), p->sharedMask, p->exclMask,
! 2705: rc ? "failed" : "ok"));
! 2706: return rc;
! 2707: }
! 2708:
! 2709: /*
! 2710: ** Implement a memory barrier or memory fence on shared memory.
! 2711: **
! 2712: ** All loads and stores begun before the barrier must complete before
! 2713: ** any load or store begun after the barrier.
! 2714: */
! 2715: static void winShmBarrier(
! 2716: sqlite3_file *fd /* Database holding the shared memory */
! 2717: ){
! 2718: UNUSED_PARAMETER(fd);
! 2719: /* MemoryBarrier(); // does not work -- do not know why not */
! 2720: winShmEnterMutex();
! 2721: winShmLeaveMutex();
! 2722: }
! 2723:
! 2724: /*
! 2725: ** This function is called to obtain a pointer to region iRegion of the
! 2726: ** shared-memory associated with the database file fd. Shared-memory regions
! 2727: ** are numbered starting from zero. Each shared-memory region is szRegion
! 2728: ** bytes in size.
! 2729: **
! 2730: ** If an error occurs, an error code is returned and *pp is set to NULL.
! 2731: **
! 2732: ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
! 2733: ** region has not been allocated (by any client, including one running in a
! 2734: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
! 2735: ** isWrite is non-zero and the requested shared-memory region has not yet
! 2736: ** been allocated, it is allocated by this function.
! 2737: **
! 2738: ** If the shared-memory region has already been allocated or is allocated by
! 2739: ** this call as described above, then it is mapped into this processes
! 2740: ** address space (if it is not already), *pp is set to point to the mapped
! 2741: ** memory and SQLITE_OK returned.
! 2742: */
! 2743: static int winShmMap(
! 2744: sqlite3_file *fd, /* Handle open on database file */
! 2745: int iRegion, /* Region to retrieve */
! 2746: int szRegion, /* Size of regions */
! 2747: int isWrite, /* True to extend file if necessary */
! 2748: void volatile **pp /* OUT: Mapped memory */
! 2749: ){
! 2750: winFile *pDbFd = (winFile*)fd;
! 2751: winShm *p = pDbFd->pShm;
! 2752: winShmNode *pShmNode;
! 2753: int rc = SQLITE_OK;
! 2754:
! 2755: if( !p ){
! 2756: rc = winOpenSharedMemory(pDbFd);
! 2757: if( rc!=SQLITE_OK ) return rc;
! 2758: p = pDbFd->pShm;
! 2759: }
! 2760: pShmNode = p->pShmNode;
! 2761:
! 2762: sqlite3_mutex_enter(pShmNode->mutex);
! 2763: assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
! 2764:
! 2765: if( pShmNode->nRegion<=iRegion ){
! 2766: struct ShmRegion *apNew; /* New aRegion[] array */
! 2767: int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
! 2768: sqlite3_int64 sz; /* Current size of wal-index file */
! 2769:
! 2770: pShmNode->szRegion = szRegion;
! 2771:
! 2772: /* The requested region is not mapped into this processes address space.
! 2773: ** Check to see if it has been allocated (i.e. if the wal-index file is
! 2774: ** large enough to contain the requested region).
! 2775: */
! 2776: rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
! 2777: if( rc!=SQLITE_OK ){
! 2778: rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(),
! 2779: "winShmMap1", pDbFd->zPath);
! 2780: goto shmpage_out;
! 2781: }
! 2782:
! 2783: if( sz<nByte ){
! 2784: /* The requested memory region does not exist. If isWrite is set to
! 2785: ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
! 2786: **
! 2787: ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
! 2788: ** the requested memory region.
! 2789: */
! 2790: if( !isWrite ) goto shmpage_out;
! 2791: rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
! 2792: if( rc!=SQLITE_OK ){
! 2793: rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(),
! 2794: "winShmMap2", pDbFd->zPath);
! 2795: goto shmpage_out;
! 2796: }
! 2797: }
! 2798:
! 2799: /* Map the requested memory region into this processes address space. */
! 2800: apNew = (struct ShmRegion *)sqlite3_realloc(
! 2801: pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
! 2802: );
! 2803: if( !apNew ){
! 2804: rc = SQLITE_IOERR_NOMEM;
! 2805: goto shmpage_out;
! 2806: }
! 2807: pShmNode->aRegion = apNew;
! 2808:
! 2809: while( pShmNode->nRegion<=iRegion ){
! 2810: HANDLE hMap; /* file-mapping handle */
! 2811: void *pMap = 0; /* Mapped memory region */
! 2812:
! 2813: hMap = osCreateFileMapping(pShmNode->hFile.h,
! 2814: NULL, PAGE_READWRITE, 0, nByte, NULL
! 2815: );
! 2816: OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n",
! 2817: (int)osGetCurrentProcessId(), pShmNode->nRegion, nByte,
! 2818: hMap ? "ok" : "failed"));
! 2819: if( hMap ){
! 2820: int iOffset = pShmNode->nRegion*szRegion;
! 2821: int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
! 2822: pMap = osMapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ,
! 2823: 0, iOffset - iOffsetShift, szRegion + iOffsetShift
! 2824: );
! 2825: OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n",
! 2826: (int)osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
! 2827: szRegion, pMap ? "ok" : "failed"));
! 2828: }
! 2829: if( !pMap ){
! 2830: pShmNode->lastErrno = osGetLastError();
! 2831: rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno,
! 2832: "winShmMap3", pDbFd->zPath);
! 2833: if( hMap ) osCloseHandle(hMap);
! 2834: goto shmpage_out;
! 2835: }
! 2836:
! 2837: pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
! 2838: pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
! 2839: pShmNode->nRegion++;
! 2840: }
! 2841: }
! 2842:
! 2843: shmpage_out:
! 2844: if( pShmNode->nRegion>iRegion ){
! 2845: int iOffset = iRegion*szRegion;
! 2846: int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
! 2847: char *p = (char *)pShmNode->aRegion[iRegion].pMap;
! 2848: *pp = (void *)&p[iOffsetShift];
! 2849: }else{
! 2850: *pp = 0;
! 2851: }
! 2852: sqlite3_mutex_leave(pShmNode->mutex);
! 2853: return rc;
! 2854: }
! 2855:
! 2856: #else
! 2857: # define winShmMap 0
! 2858: # define winShmLock 0
! 2859: # define winShmBarrier 0
! 2860: # define winShmUnmap 0
! 2861: #endif /* #ifndef SQLITE_OMIT_WAL */
! 2862:
! 2863: /*
! 2864: ** Here ends the implementation of all sqlite3_file methods.
! 2865: **
! 2866: ********************** End sqlite3_file Methods *******************************
! 2867: ******************************************************************************/
! 2868:
! 2869: /*
! 2870: ** This vector defines all the methods that can operate on an
! 2871: ** sqlite3_file for win32.
! 2872: */
! 2873: static const sqlite3_io_methods winIoMethod = {
! 2874: 2, /* iVersion */
! 2875: winClose, /* xClose */
! 2876: winRead, /* xRead */
! 2877: winWrite, /* xWrite */
! 2878: winTruncate, /* xTruncate */
! 2879: winSync, /* xSync */
! 2880: winFileSize, /* xFileSize */
! 2881: winLock, /* xLock */
! 2882: winUnlock, /* xUnlock */
! 2883: winCheckReservedLock, /* xCheckReservedLock */
! 2884: winFileControl, /* xFileControl */
! 2885: winSectorSize, /* xSectorSize */
! 2886: winDeviceCharacteristics, /* xDeviceCharacteristics */
! 2887: winShmMap, /* xShmMap */
! 2888: winShmLock, /* xShmLock */
! 2889: winShmBarrier, /* xShmBarrier */
! 2890: winShmUnmap /* xShmUnmap */
! 2891: };
! 2892:
! 2893: /****************************************************************************
! 2894: **************************** sqlite3_vfs methods ****************************
! 2895: **
! 2896: ** This division contains the implementation of methods on the
! 2897: ** sqlite3_vfs object.
! 2898: */
! 2899:
! 2900: /*
! 2901: ** Convert a UTF-8 filename into whatever form the underlying
! 2902: ** operating system wants filenames in. Space to hold the result
! 2903: ** is obtained from malloc and must be freed by the calling
! 2904: ** function.
! 2905: */
! 2906: static void *convertUtf8Filename(const char *zFilename){
! 2907: void *zConverted = 0;
! 2908: if( isNT() ){
! 2909: zConverted = utf8ToUnicode(zFilename);
! 2910: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 2911: */
! 2912: #if SQLITE_OS_WINCE==0
! 2913: }else{
! 2914: zConverted = sqlite3_win32_utf8_to_mbcs(zFilename);
! 2915: #endif
! 2916: }
! 2917: /* caller will handle out of memory */
! 2918: return zConverted;
! 2919: }
! 2920:
! 2921: /*
! 2922: ** Create a temporary file name in zBuf. zBuf must be big enough to
! 2923: ** hold at pVfs->mxPathname characters.
! 2924: */
! 2925: static int getTempname(int nBuf, char *zBuf){
! 2926: static char zChars[] =
! 2927: "abcdefghijklmnopqrstuvwxyz"
! 2928: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
! 2929: "0123456789";
! 2930: size_t i, j;
! 2931: char zTempPath[MAX_PATH+2];
! 2932:
! 2933: /* It's odd to simulate an io-error here, but really this is just
! 2934: ** using the io-error infrastructure to test that SQLite handles this
! 2935: ** function failing.
! 2936: */
! 2937: SimulateIOError( return SQLITE_IOERR );
! 2938:
! 2939: if( sqlite3_temp_directory ){
! 2940: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
! 2941: }else if( isNT() ){
! 2942: char *zMulti;
! 2943: WCHAR zWidePath[MAX_PATH];
! 2944: osGetTempPathW(MAX_PATH-30, zWidePath);
! 2945: zMulti = unicodeToUtf8(zWidePath);
! 2946: if( zMulti ){
! 2947: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
! 2948: sqlite3_free(zMulti);
! 2949: }else{
! 2950: return SQLITE_IOERR_NOMEM;
! 2951: }
! 2952: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 2953: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 2954: ** it's important to not reference them for WINCE builds.
! 2955: */
! 2956: #if SQLITE_OS_WINCE==0
! 2957: }else{
! 2958: char *zUtf8;
! 2959: char zMbcsPath[MAX_PATH];
! 2960: osGetTempPathA(MAX_PATH-30, zMbcsPath);
! 2961: zUtf8 = sqlite3_win32_mbcs_to_utf8(zMbcsPath);
! 2962: if( zUtf8 ){
! 2963: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
! 2964: sqlite3_free(zUtf8);
! 2965: }else{
! 2966: return SQLITE_IOERR_NOMEM;
! 2967: }
! 2968: #endif
! 2969: }
! 2970:
! 2971: /* Check that the output buffer is large enough for the temporary file
! 2972: ** name. If it is not, return SQLITE_ERROR.
! 2973: */
! 2974: if( (sqlite3Strlen30(zTempPath) + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){
! 2975: return SQLITE_ERROR;
! 2976: }
! 2977:
! 2978: for(i=sqlite3Strlen30(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
! 2979: zTempPath[i] = 0;
! 2980:
! 2981: sqlite3_snprintf(nBuf-18, zBuf,
! 2982: "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
! 2983: j = sqlite3Strlen30(zBuf);
! 2984: sqlite3_randomness(15, &zBuf[j]);
! 2985: for(i=0; i<15; i++, j++){
! 2986: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
! 2987: }
! 2988: zBuf[j] = 0;
! 2989: zBuf[j+1] = 0;
! 2990:
! 2991: OSTRACE(("TEMP FILENAME: %s\n", zBuf));
! 2992: return SQLITE_OK;
! 2993: }
! 2994:
! 2995: /*
! 2996: ** Open a file.
! 2997: */
! 2998: static int winOpen(
! 2999: sqlite3_vfs *pVfs, /* Not used */
! 3000: const char *zName, /* Name of the file (UTF-8) */
! 3001: sqlite3_file *id, /* Write the SQLite file handle here */
! 3002: int flags, /* Open mode flags */
! 3003: int *pOutFlags /* Status return flags */
! 3004: ){
! 3005: HANDLE h;
! 3006: DWORD lastErrno;
! 3007: DWORD dwDesiredAccess;
! 3008: DWORD dwShareMode;
! 3009: DWORD dwCreationDisposition;
! 3010: DWORD dwFlagsAndAttributes = 0;
! 3011: #if SQLITE_OS_WINCE
! 3012: int isTemp = 0;
! 3013: #endif
! 3014: winFile *pFile = (winFile*)id;
! 3015: void *zConverted; /* Filename in OS encoding */
! 3016: const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
! 3017: int cnt = 0;
! 3018:
! 3019: /* If argument zPath is a NULL pointer, this function is required to open
! 3020: ** a temporary file. Use this buffer to store the file name in.
! 3021: */
! 3022: char zTmpname[MAX_PATH+2]; /* Buffer used to create temp filename */
! 3023:
! 3024: int rc = SQLITE_OK; /* Function Return Code */
! 3025: #if !defined(NDEBUG) || SQLITE_OS_WINCE
! 3026: int eType = flags&0xFFFFFF00; /* Type of file to open */
! 3027: #endif
! 3028:
! 3029: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
! 3030: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
! 3031: int isCreate = (flags & SQLITE_OPEN_CREATE);
! 3032: #ifndef NDEBUG
! 3033: int isReadonly = (flags & SQLITE_OPEN_READONLY);
! 3034: #endif
! 3035: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
! 3036:
! 3037: #ifndef NDEBUG
! 3038: int isOpenJournal = (isCreate && (
! 3039: eType==SQLITE_OPEN_MASTER_JOURNAL
! 3040: || eType==SQLITE_OPEN_MAIN_JOURNAL
! 3041: || eType==SQLITE_OPEN_WAL
! 3042: ));
! 3043: #endif
! 3044:
! 3045: /* Check the following statements are true:
! 3046: **
! 3047: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
! 3048: ** (b) if CREATE is set, then READWRITE must also be set, and
! 3049: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
! 3050: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
! 3051: */
! 3052: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
! 3053: assert(isCreate==0 || isReadWrite);
! 3054: assert(isExclusive==0 || isCreate);
! 3055: assert(isDelete==0 || isCreate);
! 3056:
! 3057: /* The main DB, main journal, WAL file and master journal are never
! 3058: ** automatically deleted. Nor are they ever temporary files. */
! 3059: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
! 3060: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
! 3061: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
! 3062: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
! 3063:
! 3064: /* Assert that the upper layer has set one of the "file-type" flags. */
! 3065: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
! 3066: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
! 3067: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
! 3068: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
! 3069: );
! 3070:
! 3071: assert( id!=0 );
! 3072: UNUSED_PARAMETER(pVfs);
! 3073:
! 3074: pFile->h = INVALID_HANDLE_VALUE;
! 3075:
! 3076: /* If the second argument to this function is NULL, generate a
! 3077: ** temporary file name to use
! 3078: */
! 3079: if( !zUtf8Name ){
! 3080: assert(isDelete && !isOpenJournal);
! 3081: rc = getTempname(MAX_PATH+2, zTmpname);
! 3082: if( rc!=SQLITE_OK ){
! 3083: return rc;
! 3084: }
! 3085: zUtf8Name = zTmpname;
! 3086: }
! 3087:
! 3088: /* Database filenames are double-zero terminated if they are not
! 3089: ** URIs with parameters. Hence, they can always be passed into
! 3090: ** sqlite3_uri_parameter().
! 3091: */
! 3092: assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
! 3093: zUtf8Name[strlen(zUtf8Name)+1]==0 );
! 3094:
! 3095: /* Convert the filename to the system encoding. */
! 3096: zConverted = convertUtf8Filename(zUtf8Name);
! 3097: if( zConverted==0 ){
! 3098: return SQLITE_IOERR_NOMEM;
! 3099: }
! 3100:
! 3101: if( isReadWrite ){
! 3102: dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
! 3103: }else{
! 3104: dwDesiredAccess = GENERIC_READ;
! 3105: }
! 3106:
! 3107: /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
! 3108: ** created. SQLite doesn't use it to indicate "exclusive access"
! 3109: ** as it is usually understood.
! 3110: */
! 3111: if( isExclusive ){
! 3112: /* Creates a new file, only if it does not already exist. */
! 3113: /* If the file exists, it fails. */
! 3114: dwCreationDisposition = CREATE_NEW;
! 3115: }else if( isCreate ){
! 3116: /* Open existing file, or create if it doesn't exist */
! 3117: dwCreationDisposition = OPEN_ALWAYS;
! 3118: }else{
! 3119: /* Opens a file, only if it exists. */
! 3120: dwCreationDisposition = OPEN_EXISTING;
! 3121: }
! 3122:
! 3123: dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
! 3124:
! 3125: if( isDelete ){
! 3126: #if SQLITE_OS_WINCE
! 3127: dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
! 3128: isTemp = 1;
! 3129: #else
! 3130: dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
! 3131: | FILE_ATTRIBUTE_HIDDEN
! 3132: | FILE_FLAG_DELETE_ON_CLOSE;
! 3133: #endif
! 3134: }else{
! 3135: dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
! 3136: }
! 3137: /* Reports from the internet are that performance is always
! 3138: ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
! 3139: #if SQLITE_OS_WINCE
! 3140: dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
! 3141: #endif
! 3142:
! 3143: if( isNT() ){
! 3144: while( (h = osCreateFileW((LPCWSTR)zConverted,
! 3145: dwDesiredAccess,
! 3146: dwShareMode, NULL,
! 3147: dwCreationDisposition,
! 3148: dwFlagsAndAttributes,
! 3149: NULL))==INVALID_HANDLE_VALUE &&
! 3150: retryIoerr(&cnt, &lastErrno) ){}
! 3151: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 3152: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 3153: ** it's important to not reference them for WINCE builds.
! 3154: */
! 3155: #if SQLITE_OS_WINCE==0
! 3156: }else{
! 3157: while( (h = osCreateFileA((LPCSTR)zConverted,
! 3158: dwDesiredAccess,
! 3159: dwShareMode, NULL,
! 3160: dwCreationDisposition,
! 3161: dwFlagsAndAttributes,
! 3162: NULL))==INVALID_HANDLE_VALUE &&
! 3163: retryIoerr(&cnt, &lastErrno) ){}
! 3164: #endif
! 3165: }
! 3166:
! 3167: logIoerr(cnt);
! 3168:
! 3169: OSTRACE(("OPEN %d %s 0x%lx %s\n",
! 3170: h, zName, dwDesiredAccess,
! 3171: h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
! 3172:
! 3173: if( h==INVALID_HANDLE_VALUE ){
! 3174: pFile->lastErrno = lastErrno;
! 3175: winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
! 3176: sqlite3_free(zConverted);
! 3177: if( isReadWrite && !isExclusive ){
! 3178: return winOpen(pVfs, zName, id,
! 3179: ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), pOutFlags);
! 3180: }else{
! 3181: return SQLITE_CANTOPEN_BKPT;
! 3182: }
! 3183: }
! 3184:
! 3185: if( pOutFlags ){
! 3186: if( isReadWrite ){
! 3187: *pOutFlags = SQLITE_OPEN_READWRITE;
! 3188: }else{
! 3189: *pOutFlags = SQLITE_OPEN_READONLY;
! 3190: }
! 3191: }
! 3192:
! 3193: memset(pFile, 0, sizeof(*pFile));
! 3194: pFile->pMethod = &winIoMethod;
! 3195: pFile->h = h;
! 3196: pFile->lastErrno = NO_ERROR;
! 3197: pFile->pVfs = pVfs;
! 3198: pFile->pShm = 0;
! 3199: pFile->zPath = zName;
! 3200: if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
! 3201: pFile->ctrlFlags |= WINFILE_PSOW;
! 3202: }
! 3203:
! 3204: #if SQLITE_OS_WINCE
! 3205: if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB
! 3206: && !winceCreateLock(zName, pFile)
! 3207: ){
! 3208: osCloseHandle(h);
! 3209: sqlite3_free(zConverted);
! 3210: return SQLITE_CANTOPEN_BKPT;
! 3211: }
! 3212: if( isTemp ){
! 3213: pFile->zDeleteOnClose = zConverted;
! 3214: }else
! 3215: #endif
! 3216: {
! 3217: sqlite3_free(zConverted);
! 3218: }
! 3219:
! 3220: OpenCounter(+1);
! 3221: return rc;
! 3222: }
! 3223:
! 3224: /*
! 3225: ** Delete the named file.
! 3226: **
! 3227: ** Note that Windows does not allow a file to be deleted if some other
! 3228: ** process has it open. Sometimes a virus scanner or indexing program
! 3229: ** will open a journal file shortly after it is created in order to do
! 3230: ** whatever it does. While this other process is holding the
! 3231: ** file open, we will be unable to delete it. To work around this
! 3232: ** problem, we delay 100 milliseconds and try to delete again. Up
! 3233: ** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
! 3234: ** up and returning an error.
! 3235: */
! 3236: static int winDelete(
! 3237: sqlite3_vfs *pVfs, /* Not used on win32 */
! 3238: const char *zFilename, /* Name of file to delete */
! 3239: int syncDir /* Not used on win32 */
! 3240: ){
! 3241: int cnt = 0;
! 3242: int rc;
! 3243: DWORD lastErrno;
! 3244: void *zConverted;
! 3245: UNUSED_PARAMETER(pVfs);
! 3246: UNUSED_PARAMETER(syncDir);
! 3247:
! 3248: SimulateIOError(return SQLITE_IOERR_DELETE);
! 3249: zConverted = convertUtf8Filename(zFilename);
! 3250: if( zConverted==0 ){
! 3251: return SQLITE_IOERR_NOMEM;
! 3252: }
! 3253: if( isNT() ){
! 3254: rc = 1;
! 3255: while( osGetFileAttributesW(zConverted)!=INVALID_FILE_ATTRIBUTES &&
! 3256: (rc = osDeleteFileW(zConverted))==0 && retryIoerr(&cnt, &lastErrno) ){}
! 3257: rc = rc ? SQLITE_OK : SQLITE_ERROR;
! 3258: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 3259: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 3260: ** it's important to not reference them for WINCE builds.
! 3261: */
! 3262: #if SQLITE_OS_WINCE==0
! 3263: }else{
! 3264: rc = 1;
! 3265: while( osGetFileAttributesA(zConverted)!=INVALID_FILE_ATTRIBUTES &&
! 3266: (rc = osDeleteFileA(zConverted))==0 && retryIoerr(&cnt, &lastErrno) ){}
! 3267: rc = rc ? SQLITE_OK : SQLITE_ERROR;
! 3268: #endif
! 3269: }
! 3270: if( rc ){
! 3271: rc = winLogError(SQLITE_IOERR_DELETE, lastErrno,
! 3272: "winDelete", zFilename);
! 3273: }else{
! 3274: logIoerr(cnt);
! 3275: }
! 3276: sqlite3_free(zConverted);
! 3277: OSTRACE(("DELETE \"%s\" %s\n", zFilename, (rc ? "failed" : "ok" )));
! 3278: return rc;
! 3279: }
! 3280:
! 3281: /*
! 3282: ** Check the existance and status of a file.
! 3283: */
! 3284: static int winAccess(
! 3285: sqlite3_vfs *pVfs, /* Not used on win32 */
! 3286: const char *zFilename, /* Name of file to check */
! 3287: int flags, /* Type of test to make on this file */
! 3288: int *pResOut /* OUT: Result */
! 3289: ){
! 3290: DWORD attr;
! 3291: int rc = 0;
! 3292: DWORD lastErrno;
! 3293: void *zConverted;
! 3294: UNUSED_PARAMETER(pVfs);
! 3295:
! 3296: SimulateIOError( return SQLITE_IOERR_ACCESS; );
! 3297: zConverted = convertUtf8Filename(zFilename);
! 3298: if( zConverted==0 ){
! 3299: return SQLITE_IOERR_NOMEM;
! 3300: }
! 3301: if( isNT() ){
! 3302: int cnt = 0;
! 3303: WIN32_FILE_ATTRIBUTE_DATA sAttrData;
! 3304: memset(&sAttrData, 0, sizeof(sAttrData));
! 3305: while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted,
! 3306: GetFileExInfoStandard,
! 3307: &sAttrData)) && retryIoerr(&cnt, &lastErrno) ){}
! 3308: if( rc ){
! 3309: /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
! 3310: ** as if it does not exist.
! 3311: */
! 3312: if( flags==SQLITE_ACCESS_EXISTS
! 3313: && sAttrData.nFileSizeHigh==0
! 3314: && sAttrData.nFileSizeLow==0 ){
! 3315: attr = INVALID_FILE_ATTRIBUTES;
! 3316: }else{
! 3317: attr = sAttrData.dwFileAttributes;
! 3318: }
! 3319: }else{
! 3320: logIoerr(cnt);
! 3321: if( lastErrno!=ERROR_FILE_NOT_FOUND ){
! 3322: winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess", zFilename);
! 3323: sqlite3_free(zConverted);
! 3324: return SQLITE_IOERR_ACCESS;
! 3325: }else{
! 3326: attr = INVALID_FILE_ATTRIBUTES;
! 3327: }
! 3328: }
! 3329: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 3330: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 3331: ** it's important to not reference them for WINCE builds.
! 3332: */
! 3333: #if SQLITE_OS_WINCE==0
! 3334: }else{
! 3335: attr = osGetFileAttributesA((char*)zConverted);
! 3336: #endif
! 3337: }
! 3338: sqlite3_free(zConverted);
! 3339: switch( flags ){
! 3340: case SQLITE_ACCESS_READ:
! 3341: case SQLITE_ACCESS_EXISTS:
! 3342: rc = attr!=INVALID_FILE_ATTRIBUTES;
! 3343: break;
! 3344: case SQLITE_ACCESS_READWRITE:
! 3345: rc = attr!=INVALID_FILE_ATTRIBUTES &&
! 3346: (attr & FILE_ATTRIBUTE_READONLY)==0;
! 3347: break;
! 3348: default:
! 3349: assert(!"Invalid flags argument");
! 3350: }
! 3351: *pResOut = rc;
! 3352: return SQLITE_OK;
! 3353: }
! 3354:
! 3355:
! 3356: /*
! 3357: ** Turn a relative pathname into a full pathname. Write the full
! 3358: ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
! 3359: ** bytes in size.
! 3360: */
! 3361: static int winFullPathname(
! 3362: sqlite3_vfs *pVfs, /* Pointer to vfs object */
! 3363: const char *zRelative, /* Possibly relative input path */
! 3364: int nFull, /* Size of output buffer in bytes */
! 3365: char *zFull /* Output buffer */
! 3366: ){
! 3367:
! 3368: #if defined(__CYGWIN__)
! 3369: SimulateIOError( return SQLITE_ERROR );
! 3370: UNUSED_PARAMETER(nFull);
! 3371: cygwin_conv_to_full_win32_path(zRelative, zFull);
! 3372: return SQLITE_OK;
! 3373: #endif
! 3374:
! 3375: #if SQLITE_OS_WINCE
! 3376: SimulateIOError( return SQLITE_ERROR );
! 3377: UNUSED_PARAMETER(nFull);
! 3378: /* WinCE has no concept of a relative pathname, or so I am told. */
! 3379: sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
! 3380: return SQLITE_OK;
! 3381: #endif
! 3382:
! 3383: #if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
! 3384: int nByte;
! 3385: void *zConverted;
! 3386: char *zOut;
! 3387:
! 3388: /* If this path name begins with "/X:", where "X" is any alphabetic
! 3389: ** character, discard the initial "/" from the pathname.
! 3390: */
! 3391: if( zRelative[0]=='/' && sqlite3Isalpha(zRelative[1]) && zRelative[2]==':' ){
! 3392: zRelative++;
! 3393: }
! 3394:
! 3395: /* It's odd to simulate an io-error here, but really this is just
! 3396: ** using the io-error infrastructure to test that SQLite handles this
! 3397: ** function failing. This function could fail if, for example, the
! 3398: ** current working directory has been unlinked.
! 3399: */
! 3400: SimulateIOError( return SQLITE_ERROR );
! 3401: UNUSED_PARAMETER(nFull);
! 3402: zConverted = convertUtf8Filename(zRelative);
! 3403: if( zConverted==0 ){
! 3404: return SQLITE_IOERR_NOMEM;
! 3405: }
! 3406: if( isNT() ){
! 3407: LPWSTR zTemp;
! 3408: nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0) + 3;
! 3409: zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
! 3410: if( zTemp==0 ){
! 3411: sqlite3_free(zConverted);
! 3412: return SQLITE_IOERR_NOMEM;
! 3413: }
! 3414: osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0);
! 3415: sqlite3_free(zConverted);
! 3416: zOut = unicodeToUtf8(zTemp);
! 3417: sqlite3_free(zTemp);
! 3418: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 3419: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 3420: ** it's important to not reference them for WINCE builds.
! 3421: */
! 3422: #if SQLITE_OS_WINCE==0
! 3423: }else{
! 3424: char *zTemp;
! 3425: nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
! 3426: zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
! 3427: if( zTemp==0 ){
! 3428: sqlite3_free(zConverted);
! 3429: return SQLITE_IOERR_NOMEM;
! 3430: }
! 3431: osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
! 3432: sqlite3_free(zConverted);
! 3433: zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
! 3434: sqlite3_free(zTemp);
! 3435: #endif
! 3436: }
! 3437: if( zOut ){
! 3438: sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
! 3439: sqlite3_free(zOut);
! 3440: return SQLITE_OK;
! 3441: }else{
! 3442: return SQLITE_IOERR_NOMEM;
! 3443: }
! 3444: #endif
! 3445: }
! 3446:
! 3447: #ifndef SQLITE_OMIT_LOAD_EXTENSION
! 3448: /*
! 3449: ** Interfaces for opening a shared library, finding entry points
! 3450: ** within the shared library, and closing the shared library.
! 3451: */
! 3452: /*
! 3453: ** Interfaces for opening a shared library, finding entry points
! 3454: ** within the shared library, and closing the shared library.
! 3455: */
! 3456: static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
! 3457: HANDLE h;
! 3458: void *zConverted = convertUtf8Filename(zFilename);
! 3459: UNUSED_PARAMETER(pVfs);
! 3460: if( zConverted==0 ){
! 3461: return 0;
! 3462: }
! 3463: if( isNT() ){
! 3464: h = osLoadLibraryW((LPCWSTR)zConverted);
! 3465: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
! 3466: ** Since the ANSI version of these Windows API do not exist for WINCE,
! 3467: ** it's important to not reference them for WINCE builds.
! 3468: */
! 3469: #if SQLITE_OS_WINCE==0
! 3470: }else{
! 3471: h = osLoadLibraryA((char*)zConverted);
! 3472: #endif
! 3473: }
! 3474: sqlite3_free(zConverted);
! 3475: return (void*)h;
! 3476: }
! 3477: static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
! 3478: UNUSED_PARAMETER(pVfs);
! 3479: getLastErrorMsg(osGetLastError(), nBuf, zBufOut);
! 3480: }
! 3481: static void (*winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
! 3482: UNUSED_PARAMETER(pVfs);
! 3483: return (void(*)(void))osGetProcAddressA((HANDLE)pHandle, zSymbol);
! 3484: }
! 3485: static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
! 3486: UNUSED_PARAMETER(pVfs);
! 3487: osFreeLibrary((HANDLE)pHandle);
! 3488: }
! 3489: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
! 3490: #define winDlOpen 0
! 3491: #define winDlError 0
! 3492: #define winDlSym 0
! 3493: #define winDlClose 0
! 3494: #endif
! 3495:
! 3496:
! 3497: /*
! 3498: ** Write up to nBuf bytes of randomness into zBuf.
! 3499: */
! 3500: static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
! 3501: int n = 0;
! 3502: UNUSED_PARAMETER(pVfs);
! 3503: #if defined(SQLITE_TEST)
! 3504: n = nBuf;
! 3505: memset(zBuf, 0, nBuf);
! 3506: #else
! 3507: if( sizeof(SYSTEMTIME)<=nBuf-n ){
! 3508: SYSTEMTIME x;
! 3509: osGetSystemTime(&x);
! 3510: memcpy(&zBuf[n], &x, sizeof(x));
! 3511: n += sizeof(x);
! 3512: }
! 3513: if( sizeof(DWORD)<=nBuf-n ){
! 3514: DWORD pid = osGetCurrentProcessId();
! 3515: memcpy(&zBuf[n], &pid, sizeof(pid));
! 3516: n += sizeof(pid);
! 3517: }
! 3518: if( sizeof(DWORD)<=nBuf-n ){
! 3519: DWORD cnt = osGetTickCount();
! 3520: memcpy(&zBuf[n], &cnt, sizeof(cnt));
! 3521: n += sizeof(cnt);
! 3522: }
! 3523: if( sizeof(LARGE_INTEGER)<=nBuf-n ){
! 3524: LARGE_INTEGER i;
! 3525: osQueryPerformanceCounter(&i);
! 3526: memcpy(&zBuf[n], &i, sizeof(i));
! 3527: n += sizeof(i);
! 3528: }
! 3529: #endif
! 3530: return n;
! 3531: }
! 3532:
! 3533:
! 3534: /*
! 3535: ** Sleep for a little while. Return the amount of time slept.
! 3536: */
! 3537: static int winSleep(sqlite3_vfs *pVfs, int microsec){
! 3538: osSleep((microsec+999)/1000);
! 3539: UNUSED_PARAMETER(pVfs);
! 3540: return ((microsec+999)/1000)*1000;
! 3541: }
! 3542:
! 3543: /*
! 3544: ** The following variable, if set to a non-zero value, is interpreted as
! 3545: ** the number of seconds since 1970 and is used to set the result of
! 3546: ** sqlite3OsCurrentTime() during testing.
! 3547: */
! 3548: #ifdef SQLITE_TEST
! 3549: int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
! 3550: #endif
! 3551:
! 3552: /*
! 3553: ** Find the current time (in Universal Coordinated Time). Write into *piNow
! 3554: ** the current time and date as a Julian Day number times 86_400_000. In
! 3555: ** other words, write into *piNow the number of milliseconds since the Julian
! 3556: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
! 3557: ** proleptic Gregorian calendar.
! 3558: **
! 3559: ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
! 3560: ** cannot be found.
! 3561: */
! 3562: static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
! 3563: /* FILETIME structure is a 64-bit value representing the number of
! 3564: 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
! 3565: */
! 3566: FILETIME ft;
! 3567: static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000;
! 3568: #ifdef SQLITE_TEST
! 3569: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
! 3570: #endif
! 3571: /* 2^32 - to avoid use of LL and warnings in gcc */
! 3572: static const sqlite3_int64 max32BitValue =
! 3573: (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + (sqlite3_int64)294967296;
! 3574:
! 3575: #if SQLITE_OS_WINCE
! 3576: SYSTEMTIME time;
! 3577: osGetSystemTime(&time);
! 3578: /* if SystemTimeToFileTime() fails, it returns zero. */
! 3579: if (!osSystemTimeToFileTime(&time,&ft)){
! 3580: return SQLITE_ERROR;
! 3581: }
! 3582: #else
! 3583: osGetSystemTimeAsFileTime( &ft );
! 3584: #endif
! 3585:
! 3586: *piNow = winFiletimeEpoch +
! 3587: ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) +
! 3588: (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000;
! 3589:
! 3590: #ifdef SQLITE_TEST
! 3591: if( sqlite3_current_time ){
! 3592: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
! 3593: }
! 3594: #endif
! 3595: UNUSED_PARAMETER(pVfs);
! 3596: return SQLITE_OK;
! 3597: }
! 3598:
! 3599: /*
! 3600: ** Find the current time (in Universal Coordinated Time). Write the
! 3601: ** current time and date as a Julian Day number into *prNow and
! 3602: ** return 0. Return 1 if the time and date cannot be found.
! 3603: */
! 3604: static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
! 3605: int rc;
! 3606: sqlite3_int64 i;
! 3607: rc = winCurrentTimeInt64(pVfs, &i);
! 3608: if( !rc ){
! 3609: *prNow = i/86400000.0;
! 3610: }
! 3611: return rc;
! 3612: }
! 3613:
! 3614: /*
! 3615: ** The idea is that this function works like a combination of
! 3616: ** GetLastError() and FormatMessage() on Windows (or errno and
! 3617: ** strerror_r() on Unix). After an error is returned by an OS
! 3618: ** function, SQLite calls this function with zBuf pointing to
! 3619: ** a buffer of nBuf bytes. The OS layer should populate the
! 3620: ** buffer with a nul-terminated UTF-8 encoded error message
! 3621: ** describing the last IO error to have occurred within the calling
! 3622: ** thread.
! 3623: **
! 3624: ** If the error message is too large for the supplied buffer,
! 3625: ** it should be truncated. The return value of xGetLastError
! 3626: ** is zero if the error message fits in the buffer, or non-zero
! 3627: ** otherwise (if the message was truncated). If non-zero is returned,
! 3628: ** then it is not necessary to include the nul-terminator character
! 3629: ** in the output buffer.
! 3630: **
! 3631: ** Not supplying an error message will have no adverse effect
! 3632: ** on SQLite. It is fine to have an implementation that never
! 3633: ** returns an error message:
! 3634: **
! 3635: ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
! 3636: ** assert(zBuf[0]=='\0');
! 3637: ** return 0;
! 3638: ** }
! 3639: **
! 3640: ** However if an error message is supplied, it will be incorporated
! 3641: ** by sqlite into the error message available to the user using
! 3642: ** sqlite3_errmsg(), possibly making IO errors easier to debug.
! 3643: */
! 3644: static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
! 3645: UNUSED_PARAMETER(pVfs);
! 3646: return getLastErrorMsg(osGetLastError(), nBuf, zBuf);
! 3647: }
! 3648:
! 3649: /*
! 3650: ** Initialize and deinitialize the operating system interface.
! 3651: */
! 3652: int sqlite3_os_init(void){
! 3653: static sqlite3_vfs winVfs = {
! 3654: 3, /* iVersion */
! 3655: sizeof(winFile), /* szOsFile */
! 3656: MAX_PATH, /* mxPathname */
! 3657: 0, /* pNext */
! 3658: "win32", /* zName */
! 3659: 0, /* pAppData */
! 3660: winOpen, /* xOpen */
! 3661: winDelete, /* xDelete */
! 3662: winAccess, /* xAccess */
! 3663: winFullPathname, /* xFullPathname */
! 3664: winDlOpen, /* xDlOpen */
! 3665: winDlError, /* xDlError */
! 3666: winDlSym, /* xDlSym */
! 3667: winDlClose, /* xDlClose */
! 3668: winRandomness, /* xRandomness */
! 3669: winSleep, /* xSleep */
! 3670: winCurrentTime, /* xCurrentTime */
! 3671: winGetLastError, /* xGetLastError */
! 3672: winCurrentTimeInt64, /* xCurrentTimeInt64 */
! 3673: winSetSystemCall, /* xSetSystemCall */
! 3674: winGetSystemCall, /* xGetSystemCall */
! 3675: winNextSystemCall, /* xNextSystemCall */
! 3676: };
! 3677:
! 3678: /* Double-check that the aSyscall[] array has been constructed
! 3679: ** correctly. See ticket [bb3a86e890c8e96ab] */
! 3680: assert( ArraySize(aSyscall)==60 );
! 3681:
! 3682: #ifndef SQLITE_OMIT_WAL
! 3683: /* get memory map allocation granularity */
! 3684: memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
! 3685: osGetSystemInfo(&winSysInfo);
! 3686: assert(winSysInfo.dwAllocationGranularity > 0);
! 3687: #endif
! 3688:
! 3689: sqlite3_vfs_register(&winVfs, 1);
! 3690: return SQLITE_OK;
! 3691: }
! 3692:
! 3693: int sqlite3_os_end(void){
! 3694: return SQLITE_OK;
! 3695: }
! 3696:
! 3697: #endif /* SQLITE_OS_WIN */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to os_win.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src