4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 ******************************************************************************
13 ** This file contains OS interface code that is common to all
16 #include "sqliteInt.h"
19 ** If we compile with the SQLITE_TEST macro set, then the following block
20 ** of code will give us the ability to simulate a disk I/O error. This
21 ** is used for testing the I/O recovery logic.
23 #if defined(SQLITE_TEST)
24 int sqlite3_io_error_hit
= 0; /* Total number of I/O Errors */
25 int sqlite3_io_error_hardhit
= 0; /* Number of non-benign errors */
26 int sqlite3_io_error_pending
= 0; /* Count down to first I/O error */
27 int sqlite3_io_error_persist
= 0; /* True if I/O errors persist */
28 int sqlite3_io_error_benign
= 0; /* True if errors are benign */
29 int sqlite3_diskfull_pending
= 0;
30 int sqlite3_diskfull
= 0;
31 #endif /* defined(SQLITE_TEST) */
34 ** When testing, also keep a count of the number of open files.
36 #if defined(SQLITE_TEST)
37 int sqlite3_open_file_count
= 0;
38 #endif /* defined(SQLITE_TEST) */
41 ** The default SQLite sqlite3_vfs implementations do not allocate
42 ** memory (actually, os_unix.c allocates a small amount of memory
43 ** from within OsOpen()), but some third-party implementations may.
44 ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
45 ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
47 ** The following functions are instrumented for malloc() failure
53 ** sqlite3OsFileSize()
55 ** sqlite3OsCheckReservedLock()
56 ** sqlite3OsFileControl()
61 ** sqlite3OsFullPathname()
64 #if defined(SQLITE_TEST)
65 int sqlite3_memdebug_vfs_oom_test
= 1;
66 #define DO_OS_MALLOC_TEST(x) \
67 if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3JournalIsInMemory(x))) { \
68 void *pTstAlloc = sqlite3Malloc(10); \
69 if (!pTstAlloc) return SQLITE_IOERR_NOMEM_BKPT; \
70 sqlite3_free(pTstAlloc); \
73 #define DO_OS_MALLOC_TEST(x)
77 ** The following routines are convenience wrappers around methods
78 ** of the sqlite3_file object. This is mostly just syntactic sugar. All
79 ** of this would be completely automatic if SQLite were coded using
80 ** C++ instead of plain old C.
82 void sqlite3OsClose(sqlite3_file
*pId
){
84 pId
->pMethods
->xClose(pId
);
88 int sqlite3OsRead(sqlite3_file
*id
, void *pBuf
, int amt
, i64 offset
){
89 DO_OS_MALLOC_TEST(id
);
90 return id
->pMethods
->xRead(id
, pBuf
, amt
, offset
);
92 int sqlite3OsWrite(sqlite3_file
*id
, const void *pBuf
, int amt
, i64 offset
){
93 DO_OS_MALLOC_TEST(id
);
94 return id
->pMethods
->xWrite(id
, pBuf
, amt
, offset
);
96 int sqlite3OsTruncate(sqlite3_file
*id
, i64 size
){
97 return id
->pMethods
->xTruncate(id
, size
);
99 int sqlite3OsSync(sqlite3_file
*id
, int flags
){
100 DO_OS_MALLOC_TEST(id
);
101 return flags
? id
->pMethods
->xSync(id
, flags
) : SQLITE_OK
;
103 int sqlite3OsFileSize(sqlite3_file
*id
, i64
*pSize
){
104 DO_OS_MALLOC_TEST(id
);
105 return id
->pMethods
->xFileSize(id
, pSize
);
107 int sqlite3OsLock(sqlite3_file
*id
, int lockType
){
108 DO_OS_MALLOC_TEST(id
);
109 return id
->pMethods
->xLock(id
, lockType
);
111 int sqlite3OsUnlock(sqlite3_file
*id
, int lockType
){
112 return id
->pMethods
->xUnlock(id
, lockType
);
114 int sqlite3OsCheckReservedLock(sqlite3_file
*id
, int *pResOut
){
115 DO_OS_MALLOC_TEST(id
);
116 return id
->pMethods
->xCheckReservedLock(id
, pResOut
);
120 ** Use sqlite3OsFileControl() when we are doing something that might fail
121 ** and we need to know about the failures. Use sqlite3OsFileControlHint()
122 ** when simply tossing information over the wall to the VFS and we do not
123 ** really care if the VFS receives and understands the information since it
124 ** is only a hint and can be safely ignored. The sqlite3OsFileControlHint()
125 ** routine has no return value since the return value would be meaningless.
127 int sqlite3OsFileControl(sqlite3_file
*id
, int op
, void *pArg
){
129 if( op
!=SQLITE_FCNTL_COMMIT_PHASETWO
){
130 /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
131 ** is using a regular VFS, it is called after the corresponding
132 ** transaction has been committed. Injecting a fault at this point
133 ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
134 ** but the transaction is committed anyway.
136 ** The core must call OsFileControl() though, not OsFileControlHint(),
137 ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
138 ** means the commit really has failed and an error should be returned
140 DO_OS_MALLOC_TEST(id
);
143 return id
->pMethods
->xFileControl(id
, op
, pArg
);
145 void sqlite3OsFileControlHint(sqlite3_file
*id
, int op
, void *pArg
){
146 (void)id
->pMethods
->xFileControl(id
, op
, pArg
);
149 int sqlite3OsSectorSize(sqlite3_file
*id
){
150 int (*xSectorSize
)(sqlite3_file
*) = id
->pMethods
->xSectorSize
;
151 return (xSectorSize
? xSectorSize(id
) : SQLITE_DEFAULT_SECTOR_SIZE
);
153 int sqlite3OsDeviceCharacteristics(sqlite3_file
*id
){
154 return id
->pMethods
->xDeviceCharacteristics(id
);
156 #ifndef SQLITE_OMIT_WAL
157 int sqlite3OsShmLock(sqlite3_file
*id
, int offset
, int n
, int flags
){
158 return id
->pMethods
->xShmLock(id
, offset
, n
, flags
);
160 void sqlite3OsShmBarrier(sqlite3_file
*id
){
161 id
->pMethods
->xShmBarrier(id
);
163 int sqlite3OsShmUnmap(sqlite3_file
*id
, int deleteFlag
){
164 return id
->pMethods
->xShmUnmap(id
, deleteFlag
);
167 sqlite3_file
*id
, /* Database file handle */
170 int bExtend
, /* True to extend file if necessary */
171 void volatile **pp
/* OUT: Pointer to mapping */
173 DO_OS_MALLOC_TEST(id
);
174 return id
->pMethods
->xShmMap(id
, iPage
, pgsz
, bExtend
, pp
);
176 #endif /* SQLITE_OMIT_WAL */
178 #if SQLITE_MAX_MMAP_SIZE>0
179 /* The real implementation of xFetch and xUnfetch */
180 int sqlite3OsFetch(sqlite3_file
*id
, i64 iOff
, int iAmt
, void **pp
){
181 DO_OS_MALLOC_TEST(id
);
182 return id
->pMethods
->xFetch(id
, iOff
, iAmt
, pp
);
184 int sqlite3OsUnfetch(sqlite3_file
*id
, i64 iOff
, void *p
){
185 return id
->pMethods
->xUnfetch(id
, iOff
, p
);
188 /* No-op stubs to use when memory-mapped I/O is disabled */
189 int sqlite3OsFetch(sqlite3_file
*id
, i64 iOff
, int iAmt
, void **pp
){
193 int sqlite3OsUnfetch(sqlite3_file
*id
, i64 iOff
, void *p
){
199 ** The next group of routines are convenience wrappers around the
210 DO_OS_MALLOC_TEST(0);
211 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
212 ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
213 ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
214 ** reaching the VFS. */
215 rc
= pVfs
->xOpen(pVfs
, zPath
, pFile
, flags
& 0x87f7f, pFlagsOut
);
216 assert( rc
==SQLITE_OK
|| pFile
->pMethods
==0 );
219 int sqlite3OsDelete(sqlite3_vfs
*pVfs
, const char *zPath
, int dirSync
){
220 DO_OS_MALLOC_TEST(0);
221 assert( dirSync
==0 || dirSync
==1 );
222 return pVfs
->xDelete(pVfs
, zPath
, dirSync
);
230 DO_OS_MALLOC_TEST(0);
231 return pVfs
->xAccess(pVfs
, zPath
, flags
, pResOut
);
233 int sqlite3OsFullPathname(
239 DO_OS_MALLOC_TEST(0);
241 return pVfs
->xFullPathname(pVfs
, zPath
, nPathOut
, zPathOut
);
243 #ifndef SQLITE_OMIT_LOAD_EXTENSION
244 void *sqlite3OsDlOpen(sqlite3_vfs
*pVfs
, const char *zPath
){
245 return pVfs
->xDlOpen(pVfs
, zPath
);
247 void sqlite3OsDlError(sqlite3_vfs
*pVfs
, int nByte
, char *zBufOut
){
248 pVfs
->xDlError(pVfs
, nByte
, zBufOut
);
250 void (*sqlite3OsDlSym(sqlite3_vfs
*pVfs
, void *pHdle
, const char *zSym
))(void){
251 return pVfs
->xDlSym(pVfs
, pHdle
, zSym
);
253 void sqlite3OsDlClose(sqlite3_vfs
*pVfs
, void *pHandle
){
254 pVfs
->xDlClose(pVfs
, pHandle
);
256 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
257 int sqlite3OsRandomness(sqlite3_vfs
*pVfs
, int nByte
, char *zBufOut
){
258 return pVfs
->xRandomness(pVfs
, nByte
, zBufOut
);
260 int sqlite3OsSleep(sqlite3_vfs
*pVfs
, int nMicro
){
261 return pVfs
->xSleep(pVfs
, nMicro
);
263 int sqlite3OsGetLastError(sqlite3_vfs
*pVfs
){
264 return pVfs
->xGetLastError
? pVfs
->xGetLastError(pVfs
, 0, 0) : 0;
266 int sqlite3OsCurrentTimeInt64(sqlite3_vfs
*pVfs
, sqlite3_int64
*pTimeOut
){
268 /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
269 ** method to get the current date and time if that method is available
270 ** (if iVersion is 2 or greater and the function pointer is not NULL) and
271 ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
274 if( pVfs
->iVersion
>=2 && pVfs
->xCurrentTimeInt64
){
275 rc
= pVfs
->xCurrentTimeInt64(pVfs
, pTimeOut
);
278 rc
= pVfs
->xCurrentTime(pVfs
, &r
);
279 *pTimeOut
= (sqlite3_int64
)(r
*86400000.0);
284 int sqlite3OsOpenMalloc(
287 sqlite3_file
**ppFile
,
293 pFile
= (sqlite3_file
*)sqlite3MallocZero(pVfs
->szOsFile
);
295 rc
= sqlite3OsOpen(pVfs
, zFile
, pFile
, flags
, pOutFlags
);
302 rc
= SQLITE_NOMEM_BKPT
;
306 void sqlite3OsCloseFree(sqlite3_file
*pFile
){
308 sqlite3OsClose(pFile
);
313 ** This function is a wrapper around the OS specific implementation of
314 ** sqlite3_os_init(). The purpose of the wrapper is to provide the
315 ** ability to simulate a malloc failure, so that the handling of an
316 ** error in sqlite3_os_init() by the upper layers can be tested.
318 int sqlite3OsInit(void){
319 void *p
= sqlite3_malloc(10);
320 if( p
==0 ) return SQLITE_NOMEM_BKPT
;
322 return sqlite3_os_init();
326 ** The list of all registered VFS implementations.
328 static sqlite3_vfs
* SQLITE_WSD vfsList
= 0;
329 #define vfsList GLOBAL(sqlite3_vfs *, vfsList)
332 ** Locate a VFS by name. If no name is given, simply return the
333 ** first VFS on the list.
335 sqlite3_vfs
*sqlite3_vfs_find(const char *zVfs
){
336 sqlite3_vfs
*pVfs
= 0;
337 #if SQLITE_THREADSAFE
338 sqlite3_mutex
*mutex
;
340 #ifndef SQLITE_OMIT_AUTOINIT
341 int rc
= sqlite3_initialize();
344 #if SQLITE_THREADSAFE
345 mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
);
347 sqlite3_mutex_enter(mutex
);
348 for(pVfs
= vfsList
; pVfs
; pVfs
=pVfs
->pNext
){
350 if( strcmp(zVfs
, pVfs
->zName
)==0 ) break;
352 sqlite3_mutex_leave(mutex
);
357 ** Unlink a VFS from the linked list
359 static void vfsUnlink(sqlite3_vfs
*pVfs
){
360 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
)) );
363 }else if( vfsList
==pVfs
){
364 vfsList
= pVfs
->pNext
;
366 sqlite3_vfs
*p
= vfsList
;
367 while( p
->pNext
&& p
->pNext
!=pVfs
){
370 if( p
->pNext
==pVfs
){
371 p
->pNext
= pVfs
->pNext
;
377 ** Register a VFS with the system. It is harmless to register the same
378 ** VFS multiple times. The new VFS becomes the default if makeDflt is
381 int sqlite3_vfs_register(sqlite3_vfs
*pVfs
, int makeDflt
){
382 MUTEX_LOGIC(sqlite3_mutex
*mutex
;)
383 #ifndef SQLITE_OMIT_AUTOINIT
384 int rc
= sqlite3_initialize();
387 #ifdef SQLITE_ENABLE_API_ARMOR
388 if( pVfs
==0 ) return SQLITE_MISUSE_BKPT
;
391 MUTEX_LOGIC( mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
); )
392 sqlite3_mutex_enter(mutex
);
394 if( makeDflt
|| vfsList
==0 ){
395 pVfs
->pNext
= vfsList
;
398 pVfs
->pNext
= vfsList
->pNext
;
399 vfsList
->pNext
= pVfs
;
402 sqlite3_mutex_leave(mutex
);
407 ** Unregister a VFS so that it is no longer accessible.
409 int sqlite3_vfs_unregister(sqlite3_vfs
*pVfs
){
410 #if SQLITE_THREADSAFE
411 sqlite3_mutex
*mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
);
413 sqlite3_mutex_enter(mutex
);
415 sqlite3_mutex_leave(mutex
);