blob: b5e918a7272430add052db7f686570e6bb0c47fb [file] [log] [blame]
danielk1977a7a8e142008-02-13 18:25:27 +00001/*
drh054889e2005-11-30 03:20:31 +00002** 2005 November 29
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 OS interface code that is common to all
14** architectures.
15*/
drh3f459022006-01-07 16:06:07 +000016#define _SQLITE_OS_C_ 1
drh054889e2005-11-30 03:20:31 +000017#include "sqliteInt.h"
drhbd08af42007-04-05 21:58:33 +000018#undef _SQLITE_OS_C_
drh054889e2005-11-30 03:20:31 +000019
20/*
danielk1977ae72d982007-10-03 08:46:44 +000021** The default SQLite sqlite3_vfs implementations do not allocate
22** memory (actually, os_unix.c allocates a small amount of memory
23** from within OsOpen()), but some third-party implementations may.
24** So we test the effects of a malloc() failing and the sqlite3OsXXX()
25** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
26**
27** The following functions are instrumented for malloc() failure
28** testing:
29**
danielk1977ae72d982007-10-03 08:46:44 +000030** sqlite3OsRead()
31** sqlite3OsWrite()
32** sqlite3OsSync()
mistachkin6c3c1a02011-11-12 03:17:40 +000033** sqlite3OsFileSize()
danielk1977ae72d982007-10-03 08:46:44 +000034** sqlite3OsLock()
mistachkin6c3c1a02011-11-12 03:17:40 +000035** sqlite3OsCheckReservedLock()
36** sqlite3OsFileControl()
37** sqlite3OsShmMap()
38** sqlite3OsOpen()
39** sqlite3OsDelete()
40** sqlite3OsAccess()
41** sqlite3OsFullPathname()
danielk1977ae72d982007-10-03 08:46:44 +000042**
43*/
shanehfd286392010-07-02 19:49:38 +000044#if defined(SQLITE_TEST)
danc396d4a2010-07-02 11:27:43 +000045int sqlite3_memdebug_vfs_oom_test = 1;
46 #define DO_OS_MALLOC_TEST(x) \
47 if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3IsMemJournal(x))) { \
danielk1977b5a19202009-07-27 11:41:20 +000048 void *pTstAlloc = sqlite3Malloc(10); \
49 if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \
50 sqlite3_free(pTstAlloc); \
danielk1977ae72d982007-10-03 08:46:44 +000051 }
52#else
danielk1977b5a19202009-07-27 11:41:20 +000053 #define DO_OS_MALLOC_TEST(x)
danielk1977ae72d982007-10-03 08:46:44 +000054#endif
55
56/*
drh054889e2005-11-30 03:20:31 +000057** The following routines are convenience wrappers around methods
danielk197762079062007-08-15 17:08:46 +000058** of the sqlite3_file object. This is mostly just syntactic sugar. All
drh054889e2005-11-30 03:20:31 +000059** of this would be completely automatic if SQLite were coded using
60** C++ instead of plain old C.
61*/
danielk1977b4b47412007-08-17 15:53:36 +000062int sqlite3OsClose(sqlite3_file *pId){
danielk1977c7b60172007-08-22 11:22:03 +000063 int rc = SQLITE_OK;
64 if( pId->pMethods ){
65 rc = pId->pMethods->xClose(pId);
66 pId->pMethods = 0;
67 }
68 return rc;
drh054889e2005-11-30 03:20:31 +000069}
danielk197762079062007-08-15 17:08:46 +000070int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
danielk1977b5a19202009-07-27 11:41:20 +000071 DO_OS_MALLOC_TEST(id);
danielk197762079062007-08-15 17:08:46 +000072 return id->pMethods->xRead(id, pBuf, amt, offset);
drh054889e2005-11-30 03:20:31 +000073}
danielk197762079062007-08-15 17:08:46 +000074int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
danielk1977b5a19202009-07-27 11:41:20 +000075 DO_OS_MALLOC_TEST(id);
danielk197762079062007-08-15 17:08:46 +000076 return id->pMethods->xWrite(id, pBuf, amt, offset);
drh054889e2005-11-30 03:20:31 +000077}
danielk197762079062007-08-15 17:08:46 +000078int sqlite3OsTruncate(sqlite3_file *id, i64 size){
79 return id->pMethods->xTruncate(id, size);
drh054889e2005-11-30 03:20:31 +000080}
danielk197790949c22007-08-17 16:50:38 +000081int sqlite3OsSync(sqlite3_file *id, int flags){
danielk1977b5a19202009-07-27 11:41:20 +000082 DO_OS_MALLOC_TEST(id);
danielk197790949c22007-08-17 16:50:38 +000083 return id->pMethods->xSync(id, flags);
drh054889e2005-11-30 03:20:31 +000084}
danielk197762079062007-08-15 17:08:46 +000085int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
danielk1977b5a19202009-07-27 11:41:20 +000086 DO_OS_MALLOC_TEST(id);
danielk197762079062007-08-15 17:08:46 +000087 return id->pMethods->xFileSize(id, pSize);
drh054889e2005-11-30 03:20:31 +000088}
danielk197762079062007-08-15 17:08:46 +000089int sqlite3OsLock(sqlite3_file *id, int lockType){
danielk1977b5a19202009-07-27 11:41:20 +000090 DO_OS_MALLOC_TEST(id);
danielk197762079062007-08-15 17:08:46 +000091 return id->pMethods->xLock(id, lockType);
drh054889e2005-11-30 03:20:31 +000092}
danielk197762079062007-08-15 17:08:46 +000093int sqlite3OsUnlock(sqlite3_file *id, int lockType){
94 return id->pMethods->xUnlock(id, lockType);
drh054889e2005-11-30 03:20:31 +000095}
danielk1977861f7452008-06-05 11:39:11 +000096int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
danielk1977b5a19202009-07-27 11:41:20 +000097 DO_OS_MALLOC_TEST(id);
danielk1977861f7452008-06-05 11:39:11 +000098 return id->pMethods->xCheckReservedLock(id, pResOut);
drh054889e2005-11-30 03:20:31 +000099}
drhc02372c2012-01-10 17:59:59 +0000100
101/*
102** Use sqlite3OsFileControl() when we are doing something that might fail
103** and we need to know about the failures. Use sqlite3OsFileControlHint()
104** when simply tossing information over the wall to the VFS and we do not
105** really care if the VFS receives and understands the information since it
106** is only a hint and can be safely ignored. The sqlite3OsFileControlHint()
107** routine has no return value since the return value would be meaningless.
108*/
drhcc6bb3e2007-08-31 16:11:35 +0000109int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
mistachkin6c3c1a02011-11-12 03:17:40 +0000110 DO_OS_MALLOC_TEST(id);
danielk1977861f7452008-06-05 11:39:11 +0000111 return id->pMethods->xFileControl(id, op, pArg);
drhcc6bb3e2007-08-31 16:11:35 +0000112}
drhc02372c2012-01-10 17:59:59 +0000113void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
114 (void)id->pMethods->xFileControl(id, op, pArg);
dan6f2f19a2012-01-10 16:56:39 +0000115}
drhc02372c2012-01-10 17:59:59 +0000116
danielk1977bf260972008-01-22 11:50:13 +0000117int sqlite3OsSectorSize(sqlite3_file *id){
118 int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
119 return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
120}
121int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
122 return id->pMethods->xDeviceCharacteristics(id);
123}
drh73b64e42010-05-30 19:55:15 +0000124int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
125 return id->pMethods->xShmLock(id, offset, n, flags);
drhd9e5c4f2010-05-12 18:01:39 +0000126}
drh286a2882010-05-20 23:51:06 +0000127void sqlite3OsShmBarrier(sqlite3_file *id){
128 id->pMethods->xShmBarrier(id);
129}
drhe11fedc2010-07-14 00:14:30 +0000130int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){
danda9fe0c2010-07-13 18:44:03 +0000131 return id->pMethods->xShmUnmap(id, deleteFlag);
drhd9e5c4f2010-05-12 18:01:39 +0000132}
dan18801912010-06-14 14:07:50 +0000133int sqlite3OsShmMap(
danda9fe0c2010-07-13 18:44:03 +0000134 sqlite3_file *id, /* Database file handle */
135 int iPage,
136 int pgsz,
137 int bExtend, /* True to extend file if necessary */
138 void volatile **pp /* OUT: Pointer to mapping */
dan13a3cb82010-06-11 19:04:21 +0000139){
mistachkin6c3c1a02011-11-12 03:17:40 +0000140 DO_OS_MALLOC_TEST(id);
danda9fe0c2010-07-13 18:44:03 +0000141 return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
dan13a3cb82010-06-11 19:04:21 +0000142}
drh3f459022006-01-07 16:06:07 +0000143
drhd677b3d2007-08-20 22:48:41 +0000144/*
145** The next group of routines are convenience wrappers around the
146** VFS methods.
147*/
danielk1977b4b47412007-08-17 15:53:36 +0000148int sqlite3OsOpen(
149 sqlite3_vfs *pVfs,
150 const char *zPath,
151 sqlite3_file *pFile,
152 int flags,
153 int *pFlagsOut
154){
drh072db2f2009-03-25 14:24:41 +0000155 int rc;
danielk1977b5a19202009-07-27 11:41:20 +0000156 DO_OS_MALLOC_TEST(0);
dan44659c92011-12-30 05:08:41 +0000157 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
drhf1f12682009-09-09 14:17:52 +0000158 ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
159 ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
160 ** reaching the VFS. */
drh877eeb32011-07-20 17:13:30 +0000161 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
drh072db2f2009-03-25 14:24:41 +0000162 assert( rc==SQLITE_OK || pFile->pMethods==0 );
163 return rc;
drh3f459022006-01-07 16:06:07 +0000164}
danielk1977fee2d252007-08-18 10:59:19 +0000165int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
mistachkin6c3c1a02011-11-12 03:17:40 +0000166 DO_OS_MALLOC_TEST(0);
drhe3495192012-01-05 16:07:30 +0000167 assert( dirSync==0 || dirSync==1 );
drh153c62c2007-08-24 03:51:33 +0000168 return pVfs->xDelete(pVfs, zPath, dirSync);
danielk1977b4b47412007-08-17 15:53:36 +0000169}
danielk1977861f7452008-06-05 11:39:11 +0000170int sqlite3OsAccess(
171 sqlite3_vfs *pVfs,
172 const char *zPath,
173 int flags,
174 int *pResOut
175){
danielk1977b5a19202009-07-27 11:41:20 +0000176 DO_OS_MALLOC_TEST(0);
danielk1977861f7452008-06-05 11:39:11 +0000177 return pVfs->xAccess(pVfs, zPath, flags, pResOut);
danielk1977b4b47412007-08-17 15:53:36 +0000178}
danielk1977adfb9b02007-09-17 07:02:56 +0000179int sqlite3OsFullPathname(
180 sqlite3_vfs *pVfs,
181 const char *zPath,
182 int nPathOut,
183 char *zPathOut
184){
mistachkin6c3c1a02011-11-12 03:17:40 +0000185 DO_OS_MALLOC_TEST(0);
drh68ff78b2009-11-16 23:36:33 +0000186 zPathOut[0] = 0;
danielk1977adfb9b02007-09-17 07:02:56 +0000187 return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
danielk1977b4b47412007-08-17 15:53:36 +0000188}
shane75998ab2008-05-29 02:52:59 +0000189#ifndef SQLITE_OMIT_LOAD_EXTENSION
danielk1977b4b47412007-08-17 15:53:36 +0000190void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
drh153c62c2007-08-24 03:51:33 +0000191 return pVfs->xDlOpen(pVfs, zPath);
danielk1977b4b47412007-08-17 15:53:36 +0000192}
193void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
drh153c62c2007-08-24 03:51:33 +0000194 pVfs->xDlError(pVfs, nByte, zBufOut);
danielk1977b4b47412007-08-17 15:53:36 +0000195}
drh1875f7a2008-12-08 18:19:17 +0000196void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
197 return pVfs->xDlSym(pVfs, pHdle, zSym);
danielk1977b4b47412007-08-17 15:53:36 +0000198}
199void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
drh153c62c2007-08-24 03:51:33 +0000200 pVfs->xDlClose(pVfs, pHandle);
danielk1977b4b47412007-08-17 15:53:36 +0000201}
shane75998ab2008-05-29 02:52:59 +0000202#endif /* SQLITE_OMIT_LOAD_EXTENSION */
danielk1977b4b47412007-08-17 15:53:36 +0000203int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
drh153c62c2007-08-24 03:51:33 +0000204 return pVfs->xRandomness(pVfs, nByte, zBufOut);
danielk1977b4b47412007-08-17 15:53:36 +0000205}
206int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
drh153c62c2007-08-24 03:51:33 +0000207 return pVfs->xSleep(pVfs, nMicro);
danielk1977b4b47412007-08-17 15:53:36 +0000208}
drhb7e8ea22010-05-03 14:32:30 +0000209int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
210 int rc;
drhbfccdaf2010-09-01 19:29:57 +0000211 /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
212 ** method to get the current date and time if that method is available
213 ** (if iVersion is 2 or greater and the function pointer is not NULL) and
214 ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
215 ** unavailable.
216 */
drhb7e8ea22010-05-03 14:32:30 +0000217 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
218 rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
219 }else{
220 double r;
221 rc = pVfs->xCurrentTime(pVfs, &r);
222 *pTimeOut = (sqlite3_int64)(r*86400000.0);
223 }
224 return rc;
danielk1977b4b47412007-08-17 15:53:36 +0000225}
226
227int sqlite3OsOpenMalloc(
228 sqlite3_vfs *pVfs,
229 const char *zFile,
230 sqlite3_file **ppFile,
danielk1977967a4a12007-08-20 14:23:44 +0000231 int flags,
232 int *pOutFlags
danielk1977b4b47412007-08-17 15:53:36 +0000233){
234 int rc = SQLITE_NOMEM;
235 sqlite3_file *pFile;
mistachkinf1c40f42011-09-17 15:34:50 +0000236 pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
danielk1977b4b47412007-08-17 15:53:36 +0000237 if( pFile ){
danielk1977967a4a12007-08-20 14:23:44 +0000238 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
danielk1977b4b47412007-08-17 15:53:36 +0000239 if( rc!=SQLITE_OK ){
240 sqlite3_free(pFile);
241 }else{
242 *ppFile = pFile;
243 }
244 }
245 return rc;
246}
247int sqlite3OsCloseFree(sqlite3_file *pFile){
248 int rc = SQLITE_OK;
mlcreech40032982008-04-08 03:09:22 +0000249 assert( pFile );
250 rc = sqlite3OsClose(pFile);
251 sqlite3_free(pFile);
danielk1977b4b47412007-08-17 15:53:36 +0000252 return rc;
253}
254
drhd677b3d2007-08-20 22:48:41 +0000255/*
dan3d6e0602009-08-17 15:52:25 +0000256** This function is a wrapper around the OS specific implementation of
257** sqlite3_os_init(). The purpose of the wrapper is to provide the
258** ability to simulate a malloc failure, so that the handling of an
259** error in sqlite3_os_init() by the upper layers can be tested.
260*/
261int sqlite3OsInit(void){
drhadad77a2009-08-17 16:01:11 +0000262 void *p = sqlite3_malloc(10);
263 if( p==0 ) return SQLITE_NOMEM;
264 sqlite3_free(p);
dan3d6e0602009-08-17 15:52:25 +0000265 return sqlite3_os_init();
266}
267
268/*
danielk1977c0fa4c52008-06-25 17:19:00 +0000269** The list of all registered VFS implementations.
drhd677b3d2007-08-20 22:48:41 +0000270*/
danielk197795e80d62008-09-02 17:18:51 +0000271static sqlite3_vfs * SQLITE_WSD vfsList = 0;
danielk19775c8f8582008-09-02 10:22:00 +0000272#define vfsList GLOBAL(sqlite3_vfs *, vfsList)
drhd677b3d2007-08-20 22:48:41 +0000273
274/*
275** Locate a VFS by name. If no name is given, simply return the
276** first VFS on the list.
277*/
278sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
drha4189802008-06-19 16:07:07 +0000279 sqlite3_vfs *pVfs = 0;
drh18472fa2008-10-07 15:25:48 +0000280#if SQLITE_THREADSAFE
drh40257ff2008-06-13 18:24:27 +0000281 sqlite3_mutex *mutex;
282#endif
283#ifndef SQLITE_OMIT_AUTOINIT
284 int rc = sqlite3_initialize();
285 if( rc ) return 0;
286#endif
drh18472fa2008-10-07 15:25:48 +0000287#if SQLITE_THREADSAFE
danielk197759f8c082008-06-18 17:09:10 +0000288 mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
drh7e8b8482008-01-23 03:03:05 +0000289#endif
drhd677b3d2007-08-20 22:48:41 +0000290 sqlite3_mutex_enter(mutex);
291 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
292 if( zVfs==0 ) break;
293 if( strcmp(zVfs, pVfs->zName)==0 ) break;
294 }
drhd677b3d2007-08-20 22:48:41 +0000295 sqlite3_mutex_leave(mutex);
296 return pVfs;
danielk1977b4b47412007-08-17 15:53:36 +0000297}
298
drhd677b3d2007-08-20 22:48:41 +0000299/*
drhd677b3d2007-08-20 22:48:41 +0000300** Unlink a VFS from the linked list
301*/
302static void vfsUnlink(sqlite3_vfs *pVfs){
danielk197759f8c082008-06-18 17:09:10 +0000303 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
drh9bc54492007-10-23 14:49:59 +0000304 if( pVfs==0 ){
305 /* No-op */
306 }else if( vfsList==pVfs ){
drhd677b3d2007-08-20 22:48:41 +0000307 vfsList = pVfs->pNext;
drh9bc54492007-10-23 14:49:59 +0000308 }else if( vfsList ){
drhd677b3d2007-08-20 22:48:41 +0000309 sqlite3_vfs *p = vfsList;
310 while( p->pNext && p->pNext!=pVfs ){
311 p = p->pNext;
312 }
313 if( p->pNext==pVfs ){
314 p->pNext = pVfs->pNext;
315 }
316 }
317}
318
319/*
320** Register a VFS with the system. It is harmless to register the same
321** VFS multiple times. The new VFS becomes the default if makeDflt is
322** true.
323*/
324int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
drh30ddce62011-10-15 00:16:30 +0000325 MUTEX_LOGIC(sqlite3_mutex *mutex;)
drh40257ff2008-06-13 18:24:27 +0000326#ifndef SQLITE_OMIT_AUTOINIT
327 int rc = sqlite3_initialize();
328 if( rc ) return rc;
329#endif
drh30ddce62011-10-15 00:16:30 +0000330 MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
drhd677b3d2007-08-20 22:48:41 +0000331 sqlite3_mutex_enter(mutex);
332 vfsUnlink(pVfs);
333 if( makeDflt || vfsList==0 ){
334 pVfs->pNext = vfsList;
335 vfsList = pVfs;
336 }else{
337 pVfs->pNext = vfsList->pNext;
danielk197795c8a542007-09-01 06:51:27 +0000338 vfsList->pNext = pVfs;
drhd677b3d2007-08-20 22:48:41 +0000339 }
danielk1977f1da17a2007-08-21 13:07:46 +0000340 assert(vfsList);
drhd677b3d2007-08-20 22:48:41 +0000341 sqlite3_mutex_leave(mutex);
342 return SQLITE_OK;
343}
344
345/*
346** Unregister a VFS so that it is no longer accessible.
347*/
348int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
drh18472fa2008-10-07 15:25:48 +0000349#if SQLITE_THREADSAFE
danielk197759f8c082008-06-18 17:09:10 +0000350 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
drh7e8b8482008-01-23 03:03:05 +0000351#endif
drhd677b3d2007-08-20 22:48:41 +0000352 sqlite3_mutex_enter(mutex);
353 vfsUnlink(pVfs);
354 sqlite3_mutex_leave(mutex);
355 return SQLITE_OK;
356}