os.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:8k
源码类别:

数据库系统

开发平台:

C/C++

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