persistentstorage/sql/SQLite/os.c
changeset 0 08ec8eefde2f
equal deleted inserted replaced
-1:000000000000 0:08ec8eefde2f
       
     1 /*
       
     2 ** 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 **
       
    16 ** $Id: os.c,v 1.120 2008/07/28 19:34:53 drh Exp $
       
    17 */
       
    18 #define _SQLITE_OS_C_ 1
       
    19 #include "sqliteInt.h"
       
    20 #undef _SQLITE_OS_C_
       
    21 
       
    22 /*
       
    23 ** The default SQLite sqlite3_vfs implementations do not allocate
       
    24 ** memory (actually, os_unix.c allocates a small amount of memory
       
    25 ** from within OsOpen()), but some third-party implementations may.
       
    26 ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
       
    27 ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
       
    28 **
       
    29 ** The following functions are instrumented for malloc() failure 
       
    30 ** testing:
       
    31 **
       
    32 **     sqlite3OsOpen()
       
    33 **     sqlite3OsRead()
       
    34 **     sqlite3OsWrite()
       
    35 **     sqlite3OsSync()
       
    36 **     sqlite3OsLock()
       
    37 **
       
    38 */
       
    39 #if defined(SQLITE_TEST) && (SQLITE_OS_WIN==0) && 0
       
    40   #define DO_OS_MALLOC_TEST if (1) {            \
       
    41     void *pTstAlloc = sqlite3Malloc(10);       \
       
    42     if (!pTstAlloc) return SQLITE_IOERR_NOMEM;  \
       
    43     sqlite3_free(pTstAlloc);                    \
       
    44   }
       
    45 #else
       
    46   #define DO_OS_MALLOC_TEST
       
    47 #endif
       
    48 
       
    49 /*
       
    50 ** The following routines are convenience wrappers around methods
       
    51 ** of the sqlite3_file object.  This is mostly just syntactic sugar. All
       
    52 ** of this would be completely automatic if SQLite were coded using
       
    53 ** C++ instead of plain old C.
       
    54 */
       
    55 int sqlite3OsClose(sqlite3_file *pId){
       
    56   int rc = SQLITE_OK;
       
    57   if( pId->pMethods ){
       
    58     rc = pId->pMethods->xClose(pId);
       
    59     pId->pMethods = 0;
       
    60   }
       
    61   return rc;
       
    62 }
       
    63 int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
       
    64   DO_OS_MALLOC_TEST;
       
    65   return id->pMethods->xRead(id, pBuf, amt, offset);
       
    66 }
       
    67 int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
       
    68   DO_OS_MALLOC_TEST;
       
    69   return id->pMethods->xWrite(id, pBuf, amt, offset);
       
    70 }
       
    71 int sqlite3OsTruncate(sqlite3_file *id, i64 size){
       
    72   return id->pMethods->xTruncate(id, size);
       
    73 }
       
    74 int sqlite3OsSync(sqlite3_file *id, int flags){
       
    75   DO_OS_MALLOC_TEST;
       
    76   return id->pMethods->xSync(id, flags);
       
    77 }
       
    78 int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
       
    79   DO_OS_MALLOC_TEST;
       
    80   return id->pMethods->xFileSize(id, pSize);
       
    81 }
       
    82 int sqlite3OsLock(sqlite3_file *id, int lockType){
       
    83   DO_OS_MALLOC_TEST;
       
    84   return id->pMethods->xLock(id, lockType);
       
    85 }
       
    86 int sqlite3OsUnlock(sqlite3_file *id, int lockType){
       
    87   return id->pMethods->xUnlock(id, lockType);
       
    88 }
       
    89 int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
       
    90   DO_OS_MALLOC_TEST;
       
    91   return id->pMethods->xCheckReservedLock(id, pResOut);
       
    92 }
       
    93 int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
       
    94   return id->pMethods->xFileControl(id, op, pArg);
       
    95 }
       
    96 int sqlite3OsSectorSize(sqlite3_file *id){
       
    97   int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
       
    98   return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
       
    99 }
       
   100 int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
       
   101   return id->pMethods->xDeviceCharacteristics(id);
       
   102 }
       
   103 
       
   104 /*
       
   105 ** The next group of routines are convenience wrappers around the
       
   106 ** VFS methods.
       
   107 */
       
   108 int sqlite3OsOpen(
       
   109   sqlite3_vfs *pVfs, 
       
   110   const char *zPath, 
       
   111   sqlite3_file *pFile, 
       
   112   int flags, 
       
   113   int *pFlagsOut
       
   114 ){
       
   115   DO_OS_MALLOC_TEST;
       
   116   return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
       
   117 }
       
   118 int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
       
   119   return pVfs->xDelete(pVfs, zPath, dirSync);
       
   120 }
       
   121 int sqlite3OsAccess(
       
   122   sqlite3_vfs *pVfs, 
       
   123   const char *zPath, 
       
   124   int flags, 
       
   125   int *pResOut
       
   126 ){
       
   127   DO_OS_MALLOC_TEST;
       
   128   return pVfs->xAccess(pVfs, zPath, flags, pResOut);
       
   129 }
       
   130 int sqlite3OsFullPathname(
       
   131   sqlite3_vfs *pVfs, 
       
   132   const char *zPath, 
       
   133   int nPathOut, 
       
   134   char *zPathOut
       
   135 ){
       
   136   return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
       
   137 }
       
   138 #ifndef SQLITE_OMIT_LOAD_EXTENSION
       
   139 void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
       
   140   return pVfs->xDlOpen(pVfs, zPath);
       
   141 }
       
   142 void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
       
   143   pVfs->xDlError(pVfs, nByte, zBufOut);
       
   144 }
       
   145 void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
       
   146   return pVfs->xDlSym(pVfs, pHandle, zSymbol);
       
   147 }
       
   148 void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
       
   149   pVfs->xDlClose(pVfs, pHandle);
       
   150 }
       
   151 #endif /* SQLITE_OMIT_LOAD_EXTENSION */
       
   152 int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
       
   153   return pVfs->xRandomness(pVfs, nByte, zBufOut);
       
   154 }
       
   155 int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
       
   156   return pVfs->xSleep(pVfs, nMicro);
       
   157 }
       
   158 int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
       
   159   return pVfs->xCurrentTime(pVfs, pTimeOut);
       
   160 }
       
   161 
       
   162 int sqlite3OsOpenMalloc(
       
   163   sqlite3_vfs *pVfs, 
       
   164   const char *zFile, 
       
   165   sqlite3_file **ppFile, 
       
   166   int flags,
       
   167   int *pOutFlags
       
   168 ){
       
   169   int rc = SQLITE_NOMEM;
       
   170   sqlite3_file *pFile;
       
   171   pFile = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile);
       
   172   if( pFile ){
       
   173     rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
       
   174     if( rc!=SQLITE_OK ){
       
   175       sqlite3_free(pFile);
       
   176     }else{
       
   177       *ppFile = pFile;
       
   178     }
       
   179   }
       
   180   return rc;
       
   181 }
       
   182 int sqlite3OsCloseFree(sqlite3_file *pFile){
       
   183   int rc = SQLITE_OK;
       
   184   assert( pFile );
       
   185   rc = sqlite3OsClose(pFile);
       
   186   sqlite3_free(pFile);
       
   187   return rc;
       
   188 }
       
   189 
       
   190 /*
       
   191 ** The list of all registered VFS implementations.
       
   192 */
       
   193 static sqlite3_vfs *vfsList = 0;
       
   194 
       
   195 /*
       
   196 ** Locate a VFS by name.  If no name is given, simply return the
       
   197 ** first VFS on the list.
       
   198 */
       
   199 sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
       
   200   sqlite3_vfs *pVfs = 0;
       
   201 #ifndef SQLITE_MUTEX_NOOP
       
   202   sqlite3_mutex *mutex;
       
   203 #endif
       
   204 #ifndef SQLITE_OMIT_AUTOINIT
       
   205   int rc = sqlite3_initialize();
       
   206   if( rc ) return 0;
       
   207 #endif
       
   208 #ifndef SQLITE_MUTEX_NOOP
       
   209   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
       
   210 #endif
       
   211   sqlite3_mutex_enter(mutex);
       
   212   for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
       
   213     if( zVfs==0 ) break;
       
   214     if( strcmp(zVfs, pVfs->zName)==0 ) break;
       
   215   }
       
   216   sqlite3_mutex_leave(mutex);
       
   217   return pVfs;
       
   218 }
       
   219 
       
   220 /*
       
   221 ** Unlink a VFS from the linked list
       
   222 */
       
   223 static void vfsUnlink(sqlite3_vfs *pVfs){
       
   224   assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
       
   225   if( pVfs==0 ){
       
   226     /* No-op */
       
   227   }else if( vfsList==pVfs ){
       
   228     vfsList = pVfs->pNext;
       
   229   }else if( vfsList ){
       
   230     sqlite3_vfs *p = vfsList;
       
   231     while( p->pNext && p->pNext!=pVfs ){
       
   232       p = p->pNext;
       
   233     }
       
   234     if( p->pNext==pVfs ){
       
   235       p->pNext = pVfs->pNext;
       
   236     }
       
   237   }
       
   238 }
       
   239 
       
   240 /*
       
   241 ** Register a VFS with the system.  It is harmless to register the same
       
   242 ** VFS multiple times.  The new VFS becomes the default if makeDflt is
       
   243 ** true.
       
   244 */
       
   245 int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
       
   246   sqlite3_mutex *mutex = 0;
       
   247 #ifndef SQLITE_OMIT_AUTOINIT
       
   248   int rc = sqlite3_initialize();
       
   249   if( rc ) return rc;
       
   250 #endif
       
   251   mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
       
   252   sqlite3_mutex_enter(mutex);
       
   253   vfsUnlink(pVfs);
       
   254   if( makeDflt || vfsList==0 ){
       
   255     pVfs->pNext = vfsList;
       
   256     vfsList = pVfs;
       
   257   }else{
       
   258     pVfs->pNext = vfsList->pNext;
       
   259     vfsList->pNext = pVfs;
       
   260   }
       
   261   assert(vfsList);
       
   262   sqlite3_mutex_leave(mutex);
       
   263   return SQLITE_OK;
       
   264 }
       
   265 
       
   266 /*
       
   267 ** Unregister a VFS so that it is no longer accessible.
       
   268 */
       
   269 int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
       
   270 #ifndef SQLITE_MUTEX_NOOP
       
   271   sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
       
   272 #endif
       
   273   sqlite3_mutex_enter(mutex);
       
   274   vfsUnlink(pVfs);
       
   275   sqlite3_mutex_leave(mutex);
       
   276   return SQLITE_OK;
       
   277 }