1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/os.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,277 @@
1.4 +/*
1.5 +** 2005 November 29
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +******************************************************************************
1.15 +**
1.16 +** This file contains OS interface code that is common to all
1.17 +** architectures.
1.18 +**
1.19 +** $Id: os.c,v 1.120 2008/07/28 19:34:53 drh Exp $
1.20 +*/
1.21 +#define _SQLITE_OS_C_ 1
1.22 +#include "sqliteInt.h"
1.23 +#undef _SQLITE_OS_C_
1.24 +
1.25 +/*
1.26 +** The default SQLite sqlite3_vfs implementations do not allocate
1.27 +** memory (actually, os_unix.c allocates a small amount of memory
1.28 +** from within OsOpen()), but some third-party implementations may.
1.29 +** So we test the effects of a malloc() failing and the sqlite3OsXXX()
1.30 +** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
1.31 +**
1.32 +** The following functions are instrumented for malloc() failure
1.33 +** testing:
1.34 +**
1.35 +** sqlite3OsOpen()
1.36 +** sqlite3OsRead()
1.37 +** sqlite3OsWrite()
1.38 +** sqlite3OsSync()
1.39 +** sqlite3OsLock()
1.40 +**
1.41 +*/
1.42 +#if defined(SQLITE_TEST) && (SQLITE_OS_WIN==0) && 0
1.43 + #define DO_OS_MALLOC_TEST if (1) { \
1.44 + void *pTstAlloc = sqlite3Malloc(10); \
1.45 + if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \
1.46 + sqlite3_free(pTstAlloc); \
1.47 + }
1.48 +#else
1.49 + #define DO_OS_MALLOC_TEST
1.50 +#endif
1.51 +
1.52 +/*
1.53 +** The following routines are convenience wrappers around methods
1.54 +** of the sqlite3_file object. This is mostly just syntactic sugar. All
1.55 +** of this would be completely automatic if SQLite were coded using
1.56 +** C++ instead of plain old C.
1.57 +*/
1.58 +int sqlite3OsClose(sqlite3_file *pId){
1.59 + int rc = SQLITE_OK;
1.60 + if( pId->pMethods ){
1.61 + rc = pId->pMethods->xClose(pId);
1.62 + pId->pMethods = 0;
1.63 + }
1.64 + return rc;
1.65 +}
1.66 +int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
1.67 + DO_OS_MALLOC_TEST;
1.68 + return id->pMethods->xRead(id, pBuf, amt, offset);
1.69 +}
1.70 +int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
1.71 + DO_OS_MALLOC_TEST;
1.72 + return id->pMethods->xWrite(id, pBuf, amt, offset);
1.73 +}
1.74 +int sqlite3OsTruncate(sqlite3_file *id, i64 size){
1.75 + return id->pMethods->xTruncate(id, size);
1.76 +}
1.77 +int sqlite3OsSync(sqlite3_file *id, int flags){
1.78 + DO_OS_MALLOC_TEST;
1.79 + return id->pMethods->xSync(id, flags);
1.80 +}
1.81 +int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
1.82 + DO_OS_MALLOC_TEST;
1.83 + return id->pMethods->xFileSize(id, pSize);
1.84 +}
1.85 +int sqlite3OsLock(sqlite3_file *id, int lockType){
1.86 + DO_OS_MALLOC_TEST;
1.87 + return id->pMethods->xLock(id, lockType);
1.88 +}
1.89 +int sqlite3OsUnlock(sqlite3_file *id, int lockType){
1.90 + return id->pMethods->xUnlock(id, lockType);
1.91 +}
1.92 +int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
1.93 + DO_OS_MALLOC_TEST;
1.94 + return id->pMethods->xCheckReservedLock(id, pResOut);
1.95 +}
1.96 +int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
1.97 + return id->pMethods->xFileControl(id, op, pArg);
1.98 +}
1.99 +int sqlite3OsSectorSize(sqlite3_file *id){
1.100 + int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
1.101 + return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
1.102 +}
1.103 +int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
1.104 + return id->pMethods->xDeviceCharacteristics(id);
1.105 +}
1.106 +
1.107 +/*
1.108 +** The next group of routines are convenience wrappers around the
1.109 +** VFS methods.
1.110 +*/
1.111 +int sqlite3OsOpen(
1.112 + sqlite3_vfs *pVfs,
1.113 + const char *zPath,
1.114 + sqlite3_file *pFile,
1.115 + int flags,
1.116 + int *pFlagsOut
1.117 +){
1.118 + DO_OS_MALLOC_TEST;
1.119 + return pVfs->xOpen(pVfs, zPath, pFile, flags, pFlagsOut);
1.120 +}
1.121 +int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
1.122 + return pVfs->xDelete(pVfs, zPath, dirSync);
1.123 +}
1.124 +int sqlite3OsAccess(
1.125 + sqlite3_vfs *pVfs,
1.126 + const char *zPath,
1.127 + int flags,
1.128 + int *pResOut
1.129 +){
1.130 + DO_OS_MALLOC_TEST;
1.131 + return pVfs->xAccess(pVfs, zPath, flags, pResOut);
1.132 +}
1.133 +int sqlite3OsFullPathname(
1.134 + sqlite3_vfs *pVfs,
1.135 + const char *zPath,
1.136 + int nPathOut,
1.137 + char *zPathOut
1.138 +){
1.139 + return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
1.140 +}
1.141 +#ifndef SQLITE_OMIT_LOAD_EXTENSION
1.142 +void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
1.143 + return pVfs->xDlOpen(pVfs, zPath);
1.144 +}
1.145 +void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
1.146 + pVfs->xDlError(pVfs, nByte, zBufOut);
1.147 +}
1.148 +void *sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol){
1.149 + return pVfs->xDlSym(pVfs, pHandle, zSymbol);
1.150 +}
1.151 +void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
1.152 + pVfs->xDlClose(pVfs, pHandle);
1.153 +}
1.154 +#endif /* SQLITE_OMIT_LOAD_EXTENSION */
1.155 +int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
1.156 + return pVfs->xRandomness(pVfs, nByte, zBufOut);
1.157 +}
1.158 +int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
1.159 + return pVfs->xSleep(pVfs, nMicro);
1.160 +}
1.161 +int sqlite3OsCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
1.162 + return pVfs->xCurrentTime(pVfs, pTimeOut);
1.163 +}
1.164 +
1.165 +int sqlite3OsOpenMalloc(
1.166 + sqlite3_vfs *pVfs,
1.167 + const char *zFile,
1.168 + sqlite3_file **ppFile,
1.169 + int flags,
1.170 + int *pOutFlags
1.171 +){
1.172 + int rc = SQLITE_NOMEM;
1.173 + sqlite3_file *pFile;
1.174 + pFile = (sqlite3_file *)sqlite3Malloc(pVfs->szOsFile);
1.175 + if( pFile ){
1.176 + rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
1.177 + if( rc!=SQLITE_OK ){
1.178 + sqlite3_free(pFile);
1.179 + }else{
1.180 + *ppFile = pFile;
1.181 + }
1.182 + }
1.183 + return rc;
1.184 +}
1.185 +int sqlite3OsCloseFree(sqlite3_file *pFile){
1.186 + int rc = SQLITE_OK;
1.187 + assert( pFile );
1.188 + rc = sqlite3OsClose(pFile);
1.189 + sqlite3_free(pFile);
1.190 + return rc;
1.191 +}
1.192 +
1.193 +/*
1.194 +** The list of all registered VFS implementations.
1.195 +*/
1.196 +static sqlite3_vfs *vfsList = 0;
1.197 +
1.198 +/*
1.199 +** Locate a VFS by name. If no name is given, simply return the
1.200 +** first VFS on the list.
1.201 +*/
1.202 +sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
1.203 + sqlite3_vfs *pVfs = 0;
1.204 +#ifndef SQLITE_MUTEX_NOOP
1.205 + sqlite3_mutex *mutex;
1.206 +#endif
1.207 +#ifndef SQLITE_OMIT_AUTOINIT
1.208 + int rc = sqlite3_initialize();
1.209 + if( rc ) return 0;
1.210 +#endif
1.211 +#ifndef SQLITE_MUTEX_NOOP
1.212 + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
1.213 +#endif
1.214 + sqlite3_mutex_enter(mutex);
1.215 + for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
1.216 + if( zVfs==0 ) break;
1.217 + if( strcmp(zVfs, pVfs->zName)==0 ) break;
1.218 + }
1.219 + sqlite3_mutex_leave(mutex);
1.220 + return pVfs;
1.221 +}
1.222 +
1.223 +/*
1.224 +** Unlink a VFS from the linked list
1.225 +*/
1.226 +static void vfsUnlink(sqlite3_vfs *pVfs){
1.227 + assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
1.228 + if( pVfs==0 ){
1.229 + /* No-op */
1.230 + }else if( vfsList==pVfs ){
1.231 + vfsList = pVfs->pNext;
1.232 + }else if( vfsList ){
1.233 + sqlite3_vfs *p = vfsList;
1.234 + while( p->pNext && p->pNext!=pVfs ){
1.235 + p = p->pNext;
1.236 + }
1.237 + if( p->pNext==pVfs ){
1.238 + p->pNext = pVfs->pNext;
1.239 + }
1.240 + }
1.241 +}
1.242 +
1.243 +/*
1.244 +** Register a VFS with the system. It is harmless to register the same
1.245 +** VFS multiple times. The new VFS becomes the default if makeDflt is
1.246 +** true.
1.247 +*/
1.248 +int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
1.249 + sqlite3_mutex *mutex = 0;
1.250 +#ifndef SQLITE_OMIT_AUTOINIT
1.251 + int rc = sqlite3_initialize();
1.252 + if( rc ) return rc;
1.253 +#endif
1.254 + mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
1.255 + sqlite3_mutex_enter(mutex);
1.256 + vfsUnlink(pVfs);
1.257 + if( makeDflt || vfsList==0 ){
1.258 + pVfs->pNext = vfsList;
1.259 + vfsList = pVfs;
1.260 + }else{
1.261 + pVfs->pNext = vfsList->pNext;
1.262 + vfsList->pNext = pVfs;
1.263 + }
1.264 + assert(vfsList);
1.265 + sqlite3_mutex_leave(mutex);
1.266 + return SQLITE_OK;
1.267 +}
1.268 +
1.269 +/*
1.270 +** Unregister a VFS so that it is no longer accessible.
1.271 +*/
1.272 +int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
1.273 +#ifndef SQLITE_MUTEX_NOOP
1.274 + sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
1.275 +#endif
1.276 + sqlite3_mutex_enter(mutex);
1.277 + vfsUnlink(pVfs);
1.278 + sqlite3_mutex_leave(mutex);
1.279 + return SQLITE_OK;
1.280 +}