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
){
128 if( id
->pMethods
==0 ) return SQLITE_NOTFOUND
;
130 if( op
!=SQLITE_FCNTL_COMMIT_PHASETWO
131 && op
!=SQLITE_FCNTL_LOCK_TIMEOUT
133 /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
134 ** is using a regular VFS, it is called after the corresponding
135 ** transaction has been committed. Injecting a fault at this point
136 ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
137 ** but the transaction is committed anyway.
139 ** The core must call OsFileControl() though, not OsFileControlHint(),
140 ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
141 ** means the commit really has failed and an error should be returned
143 DO_OS_MALLOC_TEST(id
);
146 return id
->pMethods
->xFileControl(id
, op
, pArg
);
148 void sqlite3OsFileControlHint(sqlite3_file
*id
, int op
, void *pArg
){
149 if( id
->pMethods
) (void)id
->pMethods
->xFileControl(id
, op
, pArg
);
152 int sqlite3OsSectorSize(sqlite3_file
*id
){
153 int (*xSectorSize
)(sqlite3_file
*) = id
->pMethods
->xSectorSize
;
154 return (xSectorSize
? xSectorSize(id
) : SQLITE_DEFAULT_SECTOR_SIZE
);
156 int sqlite3OsDeviceCharacteristics(sqlite3_file
*id
){
157 return id
->pMethods
->xDeviceCharacteristics(id
);
159 #ifndef SQLITE_OMIT_WAL
160 int sqlite3OsShmLock(sqlite3_file
*id
, int offset
, int n
, int flags
){
161 return id
->pMethods
->xShmLock(id
, offset
, n
, flags
);
163 void sqlite3OsShmBarrier(sqlite3_file
*id
){
164 id
->pMethods
->xShmBarrier(id
);
166 int sqlite3OsShmUnmap(sqlite3_file
*id
, int deleteFlag
){
167 return id
->pMethods
->xShmUnmap(id
, deleteFlag
);
170 sqlite3_file
*id
, /* Database file handle */
173 int bExtend
, /* True to extend file if necessary */
174 void volatile **pp
/* OUT: Pointer to mapping */
176 DO_OS_MALLOC_TEST(id
);
177 return id
->pMethods
->xShmMap(id
, iPage
, pgsz
, bExtend
, pp
);
179 #endif /* SQLITE_OMIT_WAL */
181 #if SQLITE_MAX_MMAP_SIZE>0
182 /* The real implementation of xFetch and xUnfetch */
183 int sqlite3OsFetch(sqlite3_file
*id
, i64 iOff
, int iAmt
, void **pp
){
184 DO_OS_MALLOC_TEST(id
);
185 return id
->pMethods
->xFetch(id
, iOff
, iAmt
, pp
);
187 int sqlite3OsUnfetch(sqlite3_file
*id
, i64 iOff
, void *p
){
188 return id
->pMethods
->xUnfetch(id
, iOff
, p
);
191 /* No-op stubs to use when memory-mapped I/O is disabled */
192 int sqlite3OsFetch(sqlite3_file
*id
, i64 iOff
, int iAmt
, void **pp
){
196 int sqlite3OsUnfetch(sqlite3_file
*id
, i64 iOff
, void *p
){
202 ** The next group of routines are convenience wrappers around the
213 DO_OS_MALLOC_TEST(0);
214 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
215 ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
216 ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
217 ** reaching the VFS. */
218 rc
= pVfs
->xOpen(pVfs
, zPath
, pFile
, flags
& 0x1087f7f, pFlagsOut
);
219 assert( rc
==SQLITE_OK
|| pFile
->pMethods
==0 );
222 int sqlite3OsDelete(sqlite3_vfs
*pVfs
, const char *zPath
, int dirSync
){
223 DO_OS_MALLOC_TEST(0);
224 assert( dirSync
==0 || dirSync
==1 );
225 return pVfs
->xDelete(pVfs
, zPath
, dirSync
);
233 DO_OS_MALLOC_TEST(0);
234 return pVfs
->xAccess(pVfs
, zPath
, flags
, pResOut
);
236 int sqlite3OsFullPathname(
242 DO_OS_MALLOC_TEST(0);
244 return pVfs
->xFullPathname(pVfs
, zPath
, nPathOut
, zPathOut
);
246 #ifndef SQLITE_OMIT_LOAD_EXTENSION
247 void *sqlite3OsDlOpen(sqlite3_vfs
*pVfs
, const char *zPath
){
248 return pVfs
->xDlOpen(pVfs
, zPath
);
250 void sqlite3OsDlError(sqlite3_vfs
*pVfs
, int nByte
, char *zBufOut
){
251 pVfs
->xDlError(pVfs
, nByte
, zBufOut
);
253 void (*sqlite3OsDlSym(sqlite3_vfs
*pVfs
, void *pHdle
, const char *zSym
))(void){
254 return pVfs
->xDlSym(pVfs
, pHdle
, zSym
);
256 void sqlite3OsDlClose(sqlite3_vfs
*pVfs
, void *pHandle
){
257 pVfs
->xDlClose(pVfs
, pHandle
);
259 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
260 int sqlite3OsRandomness(sqlite3_vfs
*pVfs
, int nByte
, char *zBufOut
){
261 if( sqlite3Config
.iPrngSeed
){
262 memset(zBufOut
, 0, nByte
);
263 if( ALWAYS(nByte
>(signed)sizeof(unsigned)) ) nByte
= sizeof(unsigned int);
264 memcpy(zBufOut
, &sqlite3Config
.iPrngSeed
, nByte
);
267 return pVfs
->xRandomness(pVfs
, nByte
, zBufOut
);
271 int sqlite3OsSleep(sqlite3_vfs
*pVfs
, int nMicro
){
272 return pVfs
->xSleep(pVfs
, nMicro
);
274 int sqlite3OsGetLastError(sqlite3_vfs
*pVfs
){
275 return pVfs
->xGetLastError
? pVfs
->xGetLastError(pVfs
, 0, 0) : 0;
277 int sqlite3OsCurrentTimeInt64(sqlite3_vfs
*pVfs
, sqlite3_int64
*pTimeOut
){
279 /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
280 ** method to get the current date and time if that method is available
281 ** (if iVersion is 2 or greater and the function pointer is not NULL) and
282 ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
285 if( pVfs
->iVersion
>=2 && pVfs
->xCurrentTimeInt64
){
286 rc
= pVfs
->xCurrentTimeInt64(pVfs
, pTimeOut
);
289 rc
= pVfs
->xCurrentTime(pVfs
, &r
);
290 *pTimeOut
= (sqlite3_int64
)(r
*86400000.0);
295 int sqlite3OsOpenMalloc(
298 sqlite3_file
**ppFile
,
304 pFile
= (sqlite3_file
*)sqlite3MallocZero(pVfs
->szOsFile
);
306 rc
= sqlite3OsOpen(pVfs
, zFile
, pFile
, flags
, pOutFlags
);
313 rc
= SQLITE_NOMEM_BKPT
;
317 void sqlite3OsCloseFree(sqlite3_file
*pFile
){
319 sqlite3OsClose(pFile
);
324 ** This function is a wrapper around the OS specific implementation of
325 ** sqlite3_os_init(). The purpose of the wrapper is to provide the
326 ** ability to simulate a malloc failure, so that the handling of an
327 ** error in sqlite3_os_init() by the upper layers can be tested.
329 int sqlite3OsInit(void){
330 void *p
= sqlite3_malloc(10);
331 if( p
==0 ) return SQLITE_NOMEM_BKPT
;
333 return sqlite3_os_init();
337 ** The list of all registered VFS implementations.
339 static sqlite3_vfs
* SQLITE_WSD vfsList
= 0;
340 #define vfsList GLOBAL(sqlite3_vfs *, vfsList)
343 ** Locate a VFS by name. If no name is given, simply return the
344 ** first VFS on the list.
346 sqlite3_vfs
*sqlite3_vfs_find(const char *zVfs
){
347 sqlite3_vfs
*pVfs
= 0;
348 #if SQLITE_THREADSAFE
349 sqlite3_mutex
*mutex
;
351 #ifndef SQLITE_OMIT_AUTOINIT
352 int rc
= sqlite3_initialize();
355 #if SQLITE_THREADSAFE
356 mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN
);
358 sqlite3_mutex_enter(mutex
);
359 for(pVfs
= vfsList
; pVfs
; pVfs
=pVfs
->pNext
){
361 if( strcmp(zVfs
, pVfs
->zName
)==0 ) break;
363 sqlite3_mutex_leave(mutex
);
368 ** Unlink a VFS from the linked list
370 static void vfsUnlink(sqlite3_vfs
*pVfs
){
371 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN
)) );
374 }else if( vfsList
==pVfs
){
375 vfsList
= pVfs
->pNext
;
377 sqlite3_vfs
*p
= vfsList
;
378 while( p
->pNext
&& p
->pNext
!=pVfs
){
381 if( p
->pNext
==pVfs
){
382 p
->pNext
= pVfs
->pNext
;
388 ** Register a VFS with the system. It is harmless to register the same
389 ** VFS multiple times. The new VFS becomes the default if makeDflt is
392 int sqlite3_vfs_register(sqlite3_vfs
*pVfs
, int makeDflt
){
393 MUTEX_LOGIC(sqlite3_mutex
*mutex
;)
394 #ifndef SQLITE_OMIT_AUTOINIT
395 int rc
= sqlite3_initialize();
398 #ifdef SQLITE_ENABLE_API_ARMOR
399 if( pVfs
==0 ) return SQLITE_MISUSE_BKPT
;
402 MUTEX_LOGIC( mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN
); )
403 sqlite3_mutex_enter(mutex
);
405 if( makeDflt
|| vfsList
==0 ){
406 pVfs
->pNext
= vfsList
;
409 pVfs
->pNext
= vfsList
->pNext
;
410 vfsList
->pNext
= pVfs
;
413 sqlite3_mutex_leave(mutex
);
418 ** Unregister a VFS so that it is no longer accessible.
420 int sqlite3_vfs_unregister(sqlite3_vfs
*pVfs
){
421 MUTEX_LOGIC(sqlite3_mutex
*mutex
;)
422 #ifndef SQLITE_OMIT_AUTOINIT
423 int rc
= sqlite3_initialize();
426 MUTEX_LOGIC( mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN
); )
427 sqlite3_mutex_enter(mutex
);
429 sqlite3_mutex_leave(mutex
);