sl@0: /*
sl@0: ** 2005 November 29
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: ******************************************************************************
sl@0: **
sl@0: ** This file contains OS interface code that is common to all
sl@0: ** architectures.
sl@0: **
sl@0: ** $Id: os.c,v 1.123 2008/09/23 16:41:30 danielk1977 Exp $
sl@0: */
sl@0: #define _SQLITE_OS_C_ 1
sl@0: #include "sqliteInt.h"
sl@0: #undef _SQLITE_OS_C_
sl@0: 
sl@0: /*
sl@0: ** The default SQLite sqlite3_vfs implementations do not allocate
sl@0: ** memory (actually, os_unix.c allocates a small amount of memory
sl@0: ** from within OsOpen()), but some third-party implementations may.
sl@0: ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
sl@0: ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
sl@0: **
sl@0: ** The following functions are instrumented for malloc() failure 
sl@0: ** testing:
sl@0: **
sl@0: **     sqlite3OsOpen()
sl@0: **     sqlite3OsRead()
sl@0: **     sqlite3OsWrite()
sl@0: **     sqlite3OsSync()
sl@0: **     sqlite3OsLock()
sl@0: **
sl@0: */
sl@0: #if defined(SQLITE_TEST) && (SQLITE_OS_WIN==0)
sl@0:   #define DO_OS_MALLOC_TEST if (1) {            \
sl@0:     void *pTstAlloc = sqlite3Malloc(10);       \
sl@0:     if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \
sl@0:     sqlite3_free(pTstAlloc);                    \
sl@0:   }
sl@0: #else
sl@0:   #define DO_OS_MALLOC_TEST
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** The following routines are convenience wrappers around methods
sl@0: ** of the sqlite3_file object.  This is mostly just syntactic sugar. All
sl@0: ** of this would be completely automatic if SQLite were coded using
sl@0: ** C++ instead of plain old C.
sl@0: */
sl@0: int sqlite3OsClose(sqlite3_file *pId){
sl@0:   int rc = SQLITE_OK;
sl@0:   if( pId->pMethods ){
sl@0:     rc = pId->pMethods->xClose(pId);
sl@0:     pId->pMethods = 0;
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xRead(id, pBuf, amt, offset);
sl@0: }
sl@0: int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xWrite(id, pBuf, amt, offset);
sl@0: }
sl@0: int sqlite3OsTruncate(sqlite3_file *id, i64 size){
sl@0:   return id->pMethods->xTruncate(id, size);
sl@0: }
sl@0: int sqlite3OsSync(sqlite3_file *id, int flags){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xSync(id, flags);
sl@0: }
sl@0: int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xFileSize(id, pSize);
sl@0: }
sl@0: int sqlite3OsLock(sqlite3_file *id, int lockType){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xLock(id, lockType);
sl@0: }
sl@0: int sqlite3OsUnlock(sqlite3_file *id, int lockType){
sl@0:   return id->pMethods->xUnlock(id, lockType);
sl@0: }
sl@0: int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return id->pMethods->xCheckReservedLock(id, pResOut);
sl@0: }
sl@0: int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
sl@0:   return id->pMethods->xFileControl(id, op, pArg);
sl@0: }
sl@0: int sqlite3OsSectorSize(sqlite3_file *id){
sl@0:   int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
sl@0:   return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
sl@0: }
sl@0: int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
sl@0:   return id->pMethods->xDeviceCharacteristics(id);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The next group of routines are convenience wrappers around the
sl@0: ** VFS methods.
sl@0: */
sl@0: int sqlite3OsOpen(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zPath, 
sl@0:   sqlite3_file *pFile, 
sl@0:   int flags, 
sl@0:   int *pFlagsOut
sl@0: ){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
sl@0: }
sl@0: int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
sl@0:   return pVfs->xDelete(pVfs, zPath, dirSync);
sl@0: }
sl@0: int sqlite3OsAccess(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zPath, 
sl@0:   int flags, 
sl@0:   int *pResOut
sl@0: ){
sl@0:   DO_OS_MALLOC_TEST;
sl@0:   return pVfs->xAccess(pVfs, zPath, flags, pResOut);
sl@0: }
sl@0: int sqlite3OsFullPathname(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zPath, 
sl@0:   int nPathOut, 
sl@0:   char *zPathOut
sl@0: ){
sl@0:   return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_LOAD_EXTENSION
sl@0: void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
sl@0:   return pVfs->xDlOpen(pVfs, zPath);
sl@0: }
sl@0: void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
sl@0:   pVfs->xDlError(pVfs, nByte, zBufOut);
sl@0: }
sl@0: void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
sl@0:   return pVfs->xDlSym(pVfs, pHandle, zSymbol);
sl@0: }
sl@0: void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
sl@0:   pVfs->xDlClose(pVfs, pHandle);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_LOAD_EXTENSION */
sl@0: int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
sl@0:   return pVfs->xRandomness(pVfs, nByte, zBufOut);
sl@0: }
sl@0: int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
sl@0:   return pVfs->xSleep(pVfs, nMicro);
sl@0: }
sl@0: int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
sl@0:   return pVfs->xCurrentTime(pVfs, pTimeOut);
sl@0: }
sl@0: 
sl@0: int sqlite3OsOpenMalloc(
sl@0:   sqlite3_vfs *pVfs, 
sl@0:   const char *zFile, 
sl@0:   sqlite3_file **ppFile, 
sl@0:   int flags,
sl@0:   int *pOutFlags
sl@0: ){
sl@0:   int rc = SQLITE_NOMEM;
sl@0:   sqlite3_file *pFile;
sl@0:   pFile = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile);
sl@0:   if( pFile ){
sl@0:     rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
sl@0:     if( rc!=SQLITE_OK ){
sl@0:       sqlite3_free(pFile);
sl@0:     }else{
sl@0:       *ppFile = pFile;
sl@0:     }
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: int sqlite3OsCloseFree(sqlite3_file *pFile){
sl@0:   int rc = SQLITE_OK;
sl@0:   assert( pFile );
sl@0:   rc = sqlite3OsClose(pFile);
sl@0:   sqlite3_free(pFile);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The list of all registered VFS implementations.
sl@0: */
sl@0: static sqlite3_vfs * SQLITE_WSD vfsList = 0;
sl@0: #define vfsList GLOBAL(sqlite3_vfs *, vfsList)
sl@0: 
sl@0: /*
sl@0: ** Locate a VFS by name.  If no name is given, simply return the
sl@0: ** first VFS on the list.
sl@0: */
sl@0: SQLITE_EXPORT sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
sl@0:   sqlite3_vfs *pVfs = 0;
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0:   sqlite3_mutex *mutex;
sl@0: #endif
sl@0: #ifndef SQLITE_OMIT_AUTOINIT
sl@0:   int rc = sqlite3_initialize();
sl@0:   if( rc ) return 0;
sl@0: #endif
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0:   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0: #endif
sl@0:   sqlite3_mutex_enter(mutex);
sl@0:   for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
sl@0:     if( zVfs==0 ) break;
sl@0:     if( strcmp(zVfs, pVfs->zName)==0 ) break;
sl@0:   }
sl@0:   sqlite3_mutex_leave(mutex);
sl@0:   return pVfs;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Unlink a VFS from the linked list
sl@0: */
sl@0: static void vfsUnlink(sqlite3_vfs *pVfs){
sl@0:   assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
sl@0:   if( pVfs==0 ){
sl@0:     /* No-op */
sl@0:   }else if( vfsList==pVfs ){
sl@0:     vfsList = pVfs->pNext;
sl@0:   }else if( vfsList ){
sl@0:     sqlite3_vfs *p = vfsList;
sl@0:     while( p->pNext && p->pNext!=pVfs ){
sl@0:       p = p->pNext;
sl@0:     }
sl@0:     if( p->pNext==pVfs ){
sl@0:       p->pNext = pVfs->pNext;
sl@0:     }
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Register a VFS with the system.  It is harmless to register the same
sl@0: ** VFS multiple times.  The new VFS becomes the default if makeDflt is
sl@0: ** true.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
sl@0:   sqlite3_mutex *mutex = 0;
sl@0: #ifndef SQLITE_OMIT_AUTOINIT
sl@0:   int rc = sqlite3_initialize();
sl@0:   if( rc ) return rc;
sl@0: #endif
sl@0:   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0:   sqlite3_mutex_enter(mutex);
sl@0:   vfsUnlink(pVfs);
sl@0:   if( makeDflt || vfsList==0 ){
sl@0:     pVfs->pNext = vfsList;
sl@0:     vfsList = pVfs;
sl@0:   }else{
sl@0:     pVfs->pNext = vfsList->pNext;
sl@0:     vfsList->pNext = pVfs;
sl@0:   }
sl@0:   assert(vfsList);
sl@0:   sqlite3_mutex_leave(mutex);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Unregister a VFS so that it is no longer accessible.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0:   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0: #endif
sl@0:   sqlite3_mutex_enter(mutex);
sl@0:   vfsUnlink(pVfs);
sl@0:   sqlite3_mutex_leave(mutex);
sl@0:   return SQLITE_OK;
sl@0: }