Annotation of embedaddon/sqlite3/ext/async/sqlite3async.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2005 December 14
! 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: ** $Id: sqlite3async.c,v 1.7 2009/07/18 11:52:04 danielk1977 Exp $
! 14: **
! 15: ** This file contains the implementation of an asynchronous IO backend
! 16: ** for SQLite.
! 17: */
! 18:
! 19: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO)
! 20:
! 21: #include "sqlite3async.h"
! 22: #include "sqlite3.h"
! 23: #include <stdarg.h>
! 24: #include <string.h>
! 25: #include <assert.h>
! 26:
! 27: /* Useful macros used in several places */
! 28: #define MIN(x,y) ((x)<(y)?(x):(y))
! 29: #define MAX(x,y) ((x)>(y)?(x):(y))
! 30:
! 31: #ifndef SQLITE_AMALGAMATION
! 32: /* Macro to mark parameters as unused and silence compiler warnings. */
! 33: #define UNUSED_PARAMETER(x) (void)(x)
! 34: #endif
! 35:
! 36: /* Forward references */
! 37: typedef struct AsyncWrite AsyncWrite;
! 38: typedef struct AsyncFile AsyncFile;
! 39: typedef struct AsyncFileData AsyncFileData;
! 40: typedef struct AsyncFileLock AsyncFileLock;
! 41: typedef struct AsyncLock AsyncLock;
! 42:
! 43: /* Enable for debugging */
! 44: #ifndef NDEBUG
! 45: #include <stdio.h>
! 46: static int sqlite3async_trace = 0;
! 47: # define ASYNC_TRACE(X) if( sqlite3async_trace ) asyncTrace X
! 48: static void asyncTrace(const char *zFormat, ...){
! 49: char *z;
! 50: va_list ap;
! 51: va_start(ap, zFormat);
! 52: z = sqlite3_vmprintf(zFormat, ap);
! 53: va_end(ap);
! 54: fprintf(stderr, "[%d] %s", 0 /* (int)pthread_self() */, z);
! 55: sqlite3_free(z);
! 56: }
! 57: #else
! 58: # define ASYNC_TRACE(X)
! 59: #endif
! 60:
! 61: /*
! 62: ** THREAD SAFETY NOTES
! 63: **
! 64: ** Basic rules:
! 65: **
! 66: ** * Both read and write access to the global write-op queue must be
! 67: ** protected by the async.queueMutex. As are the async.ioError and
! 68: ** async.nFile variables.
! 69: **
! 70: ** * The async.pLock list and all AsyncLock and AsyncFileLock
! 71: ** structures must be protected by the async.lockMutex mutex.
! 72: **
! 73: ** * The file handles from the underlying system are not assumed to
! 74: ** be thread safe.
! 75: **
! 76: ** * See the last two paragraphs under "The Writer Thread" for
! 77: ** an assumption to do with file-handle synchronization by the Os.
! 78: **
! 79: ** Deadlock prevention:
! 80: **
! 81: ** There are three mutex used by the system: the "writer" mutex,
! 82: ** the "queue" mutex and the "lock" mutex. Rules are:
! 83: **
! 84: ** * It is illegal to block on the writer mutex when any other mutex
! 85: ** are held, and
! 86: **
! 87: ** * It is illegal to block on the queue mutex when the lock mutex
! 88: ** is held.
! 89: **
! 90: ** i.e. mutex's must be grabbed in the order "writer", "queue", "lock".
! 91: **
! 92: ** File system operations (invoked by SQLite thread):
! 93: **
! 94: ** xOpen
! 95: ** xDelete
! 96: ** xFileExists
! 97: **
! 98: ** File handle operations (invoked by SQLite thread):
! 99: **
! 100: ** asyncWrite, asyncClose, asyncTruncate, asyncSync
! 101: **
! 102: ** The operations above add an entry to the global write-op list. They
! 103: ** prepare the entry, acquire the async.queueMutex momentarily while
! 104: ** list pointers are manipulated to insert the new entry, then release
! 105: ** the mutex and signal the writer thread to wake up in case it happens
! 106: ** to be asleep.
! 107: **
! 108: **
! 109: ** asyncRead, asyncFileSize.
! 110: **
! 111: ** Read operations. Both of these read from both the underlying file
! 112: ** first then adjust their result based on pending writes in the
! 113: ** write-op queue. So async.queueMutex is held for the duration
! 114: ** of these operations to prevent other threads from changing the
! 115: ** queue in mid operation.
! 116: **
! 117: **
! 118: ** asyncLock, asyncUnlock, asyncCheckReservedLock
! 119: **
! 120: ** These primitives implement in-process locking using a hash table
! 121: ** on the file name. Files are locked correctly for connections coming
! 122: ** from the same process. But other processes cannot see these locks
! 123: ** and will therefore not honor them.
! 124: **
! 125: **
! 126: ** The writer thread:
! 127: **
! 128: ** The async.writerMutex is used to make sure only there is only
! 129: ** a single writer thread running at a time.
! 130: **
! 131: ** Inside the writer thread is a loop that works like this:
! 132: **
! 133: ** WHILE (write-op list is not empty)
! 134: ** Do IO operation at head of write-op list
! 135: ** Remove entry from head of write-op list
! 136: ** END WHILE
! 137: **
! 138: ** The async.queueMutex is always held during the <write-op list is
! 139: ** not empty> test, and when the entry is removed from the head
! 140: ** of the write-op list. Sometimes it is held for the interim
! 141: ** period (while the IO is performed), and sometimes it is
! 142: ** relinquished. It is relinquished if (a) the IO op is an
! 143: ** ASYNC_CLOSE or (b) when the file handle was opened, two of
! 144: ** the underlying systems handles were opened on the same
! 145: ** file-system entry.
! 146: **
! 147: ** If condition (b) above is true, then one file-handle
! 148: ** (AsyncFile.pBaseRead) is used exclusively by sqlite threads to read the
! 149: ** file, the other (AsyncFile.pBaseWrite) by sqlite3_async_flush()
! 150: ** threads to perform write() operations. This means that read
! 151: ** operations are not blocked by asynchronous writes (although
! 152: ** asynchronous writes may still be blocked by reads).
! 153: **
! 154: ** This assumes that the OS keeps two handles open on the same file
! 155: ** properly in sync. That is, any read operation that starts after a
! 156: ** write operation on the same file system entry has completed returns
! 157: ** data consistent with the write. We also assume that if one thread
! 158: ** reads a file while another is writing it all bytes other than the
! 159: ** ones actually being written contain valid data.
! 160: **
! 161: ** If the above assumptions are not true, set the preprocessor symbol
! 162: ** SQLITE_ASYNC_TWO_FILEHANDLES to 0.
! 163: */
! 164:
! 165:
! 166: #ifndef NDEBUG
! 167: # define TESTONLY( X ) X
! 168: #else
! 169: # define TESTONLY( X )
! 170: #endif
! 171:
! 172: /*
! 173: ** PORTING FUNCTIONS
! 174: **
! 175: ** There are two definitions of the following functions. One for pthreads
! 176: ** compatible systems and one for Win32. These functions isolate the OS
! 177: ** specific code required by each platform.
! 178: **
! 179: ** The system uses three mutexes and a single condition variable. To
! 180: ** block on a mutex, async_mutex_enter() is called. The parameter passed
! 181: ** to async_mutex_enter(), which must be one of ASYNC_MUTEX_LOCK,
! 182: ** ASYNC_MUTEX_QUEUE or ASYNC_MUTEX_WRITER, identifies which of the three
! 183: ** mutexes to lock. Similarly, to unlock a mutex, async_mutex_leave() is
! 184: ** called with a parameter identifying the mutex being unlocked. Mutexes
! 185: ** are not recursive - it is an error to call async_mutex_enter() to
! 186: ** lock a mutex that is already locked, or to call async_mutex_leave()
! 187: ** to unlock a mutex that is not currently locked.
! 188: **
! 189: ** The async_cond_wait() and async_cond_signal() functions are modelled
! 190: ** on the pthreads functions with similar names. The first parameter to
! 191: ** both functions is always ASYNC_COND_QUEUE. When async_cond_wait()
! 192: ** is called the mutex identified by the second parameter must be held.
! 193: ** The mutex is unlocked, and the calling thread simultaneously begins
! 194: ** waiting for the condition variable to be signalled by another thread.
! 195: ** After another thread signals the condition variable, the calling
! 196: ** thread stops waiting, locks mutex eMutex and returns. The
! 197: ** async_cond_signal() function is used to signal the condition variable.
! 198: ** It is assumed that the mutex used by the thread calling async_cond_wait()
! 199: ** is held by the caller of async_cond_signal() (otherwise there would be
! 200: ** a race condition).
! 201: **
! 202: ** It is guaranteed that no other thread will call async_cond_wait() when
! 203: ** there is already a thread waiting on the condition variable.
! 204: **
! 205: ** The async_sched_yield() function is called to suggest to the operating
! 206: ** system that it would be a good time to shift the current thread off the
! 207: ** CPU. The system will still work if this function is not implemented
! 208: ** (it is not currently implemented for win32), but it might be marginally
! 209: ** more efficient if it is.
! 210: */
! 211: static void async_mutex_enter(int eMutex);
! 212: static void async_mutex_leave(int eMutex);
! 213: static void async_cond_wait(int eCond, int eMutex);
! 214: static void async_cond_signal(int eCond);
! 215: static void async_sched_yield(void);
! 216:
! 217: /*
! 218: ** There are also two definitions of the following. async_os_initialize()
! 219: ** is called when the asynchronous VFS is first installed, and os_shutdown()
! 220: ** is called when it is uninstalled (from within sqlite3async_shutdown()).
! 221: **
! 222: ** For pthreads builds, both of these functions are no-ops. For win32,
! 223: ** they provide an opportunity to initialize and finalize the required
! 224: ** mutex and condition variables.
! 225: **
! 226: ** If async_os_initialize() returns other than zero, then the initialization
! 227: ** fails and SQLITE_ERROR is returned to the user.
! 228: */
! 229: static int async_os_initialize(void);
! 230: static void async_os_shutdown(void);
! 231:
! 232: /* Values for use as the 'eMutex' argument of the above functions. The
! 233: ** integer values assigned to these constants are important for assert()
! 234: ** statements that verify that mutexes are locked in the correct order.
! 235: ** Specifically, it is unsafe to try to lock mutex N while holding a lock
! 236: ** on mutex M if (M<=N).
! 237: */
! 238: #define ASYNC_MUTEX_LOCK 0
! 239: #define ASYNC_MUTEX_QUEUE 1
! 240: #define ASYNC_MUTEX_WRITER 2
! 241:
! 242: /* Values for use as the 'eCond' argument of the above functions. */
! 243: #define ASYNC_COND_QUEUE 0
! 244:
! 245: /*************************************************************************
! 246: ** Start of OS specific code.
! 247: */
! 248: #if SQLITE_OS_WIN || defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
! 249:
! 250: #include <windows.h>
! 251:
! 252: /* The following block contains the win32 specific code. */
! 253:
! 254: #define mutex_held(X) (GetCurrentThreadId()==primitives.aHolder[X])
! 255:
! 256: static struct AsyncPrimitives {
! 257: int isInit;
! 258: DWORD aHolder[3];
! 259: CRITICAL_SECTION aMutex[3];
! 260: HANDLE aCond[1];
! 261: } primitives = { 0 };
! 262:
! 263: static int async_os_initialize(void){
! 264: if( !primitives.isInit ){
! 265: primitives.aCond[0] = CreateEvent(NULL, TRUE, FALSE, 0);
! 266: if( primitives.aCond[0]==NULL ){
! 267: return 1;
! 268: }
! 269: InitializeCriticalSection(&primitives.aMutex[0]);
! 270: InitializeCriticalSection(&primitives.aMutex[1]);
! 271: InitializeCriticalSection(&primitives.aMutex[2]);
! 272: primitives.isInit = 1;
! 273: }
! 274: return 0;
! 275: }
! 276: static void async_os_shutdown(void){
! 277: if( primitives.isInit ){
! 278: DeleteCriticalSection(&primitives.aMutex[0]);
! 279: DeleteCriticalSection(&primitives.aMutex[1]);
! 280: DeleteCriticalSection(&primitives.aMutex[2]);
! 281: CloseHandle(primitives.aCond[0]);
! 282: primitives.isInit = 0;
! 283: }
! 284: }
! 285:
! 286: /* The following block contains the Win32 specific code. */
! 287: static void async_mutex_enter(int eMutex){
! 288: assert( eMutex==0 || eMutex==1 || eMutex==2 );
! 289: assert( eMutex!=2 || (!mutex_held(0) && !mutex_held(1) && !mutex_held(2)) );
! 290: assert( eMutex!=1 || (!mutex_held(0) && !mutex_held(1)) );
! 291: assert( eMutex!=0 || (!mutex_held(0)) );
! 292: EnterCriticalSection(&primitives.aMutex[eMutex]);
! 293: TESTONLY( primitives.aHolder[eMutex] = GetCurrentThreadId(); )
! 294: }
! 295: static void async_mutex_leave(int eMutex){
! 296: assert( eMutex==0 || eMutex==1 || eMutex==2 );
! 297: assert( mutex_held(eMutex) );
! 298: TESTONLY( primitives.aHolder[eMutex] = 0; )
! 299: LeaveCriticalSection(&primitives.aMutex[eMutex]);
! 300: }
! 301: static void async_cond_wait(int eCond, int eMutex){
! 302: ResetEvent(primitives.aCond[eCond]);
! 303: async_mutex_leave(eMutex);
! 304: WaitForSingleObject(primitives.aCond[eCond], INFINITE);
! 305: async_mutex_enter(eMutex);
! 306: }
! 307: static void async_cond_signal(int eCond){
! 308: assert( mutex_held(ASYNC_MUTEX_QUEUE) );
! 309: SetEvent(primitives.aCond[eCond]);
! 310: }
! 311: static void async_sched_yield(void){
! 312: Sleep(0);
! 313: }
! 314: #else
! 315:
! 316: /* The following block contains the pthreads specific code. */
! 317: #include <pthread.h>
! 318: #include <sched.h>
! 319:
! 320: #define mutex_held(X) pthread_equal(primitives.aHolder[X], pthread_self())
! 321:
! 322: static int async_os_initialize(void) {return 0;}
! 323: static void async_os_shutdown(void) {}
! 324:
! 325: static struct AsyncPrimitives {
! 326: pthread_mutex_t aMutex[3];
! 327: pthread_cond_t aCond[1];
! 328: pthread_t aHolder[3];
! 329: } primitives = {
! 330: { PTHREAD_MUTEX_INITIALIZER,
! 331: PTHREAD_MUTEX_INITIALIZER,
! 332: PTHREAD_MUTEX_INITIALIZER
! 333: } , {
! 334: PTHREAD_COND_INITIALIZER
! 335: } , { 0, 0, 0 }
! 336: };
! 337:
! 338: static void async_mutex_enter(int eMutex){
! 339: assert( eMutex==0 || eMutex==1 || eMutex==2 );
! 340: assert( eMutex!=2 || (!mutex_held(0) && !mutex_held(1) && !mutex_held(2)) );
! 341: assert( eMutex!=1 || (!mutex_held(0) && !mutex_held(1)) );
! 342: assert( eMutex!=0 || (!mutex_held(0)) );
! 343: pthread_mutex_lock(&primitives.aMutex[eMutex]);
! 344: TESTONLY( primitives.aHolder[eMutex] = pthread_self(); )
! 345: }
! 346: static void async_mutex_leave(int eMutex){
! 347: assert( eMutex==0 || eMutex==1 || eMutex==2 );
! 348: assert( mutex_held(eMutex) );
! 349: TESTONLY( primitives.aHolder[eMutex] = 0; )
! 350: pthread_mutex_unlock(&primitives.aMutex[eMutex]);
! 351: }
! 352: static void async_cond_wait(int eCond, int eMutex){
! 353: assert( eMutex==0 || eMutex==1 || eMutex==2 );
! 354: assert( mutex_held(eMutex) );
! 355: TESTONLY( primitives.aHolder[eMutex] = 0; )
! 356: pthread_cond_wait(&primitives.aCond[eCond], &primitives.aMutex[eMutex]);
! 357: TESTONLY( primitives.aHolder[eMutex] = pthread_self(); )
! 358: }
! 359: static void async_cond_signal(int eCond){
! 360: assert( mutex_held(ASYNC_MUTEX_QUEUE) );
! 361: pthread_cond_signal(&primitives.aCond[eCond]);
! 362: }
! 363: static void async_sched_yield(void){
! 364: sched_yield();
! 365: }
! 366: #endif
! 367: /*
! 368: ** End of OS specific code.
! 369: *************************************************************************/
! 370:
! 371: #define assert_mutex_is_held(X) assert( mutex_held(X) )
! 372:
! 373:
! 374: #ifndef SQLITE_ASYNC_TWO_FILEHANDLES
! 375: /* #define SQLITE_ASYNC_TWO_FILEHANDLES 0 */
! 376: #define SQLITE_ASYNC_TWO_FILEHANDLES 1
! 377: #endif
! 378:
! 379: /*
! 380: ** State information is held in the static variable "async" defined
! 381: ** as the following structure.
! 382: **
! 383: ** Both async.ioError and async.nFile are protected by async.queueMutex.
! 384: */
! 385: static struct TestAsyncStaticData {
! 386: AsyncWrite *pQueueFirst; /* Next write operation to be processed */
! 387: AsyncWrite *pQueueLast; /* Last write operation on the list */
! 388: AsyncLock *pLock; /* Linked list of all AsyncLock structures */
! 389: volatile int ioDelay; /* Extra delay between write operations */
! 390: volatile int eHalt; /* One of the SQLITEASYNC_HALT_XXX values */
! 391: volatile int bLockFiles; /* Current value of "lockfiles" parameter */
! 392: int ioError; /* True if an IO error has occurred */
! 393: int nFile; /* Number of open files (from sqlite pov) */
! 394: } async = { 0,0,0,0,0,1,0,0 };
! 395:
! 396: /* Possible values of AsyncWrite.op */
! 397: #define ASYNC_NOOP 0
! 398: #define ASYNC_WRITE 1
! 399: #define ASYNC_SYNC 2
! 400: #define ASYNC_TRUNCATE 3
! 401: #define ASYNC_CLOSE 4
! 402: #define ASYNC_DELETE 5
! 403: #define ASYNC_OPENEXCLUSIVE 6
! 404: #define ASYNC_UNLOCK 7
! 405:
! 406: /* Names of opcodes. Used for debugging only.
! 407: ** Make sure these stay in sync with the macros above!
! 408: */
! 409: static const char *azOpcodeName[] = {
! 410: "NOOP", "WRITE", "SYNC", "TRUNCATE", "CLOSE", "DELETE", "OPENEX", "UNLOCK"
! 411: };
! 412:
! 413: /*
! 414: ** Entries on the write-op queue are instances of the AsyncWrite
! 415: ** structure, defined here.
! 416: **
! 417: ** The interpretation of the iOffset and nByte variables varies depending
! 418: ** on the value of AsyncWrite.op:
! 419: **
! 420: ** ASYNC_NOOP:
! 421: ** No values used.
! 422: **
! 423: ** ASYNC_WRITE:
! 424: ** iOffset -> Offset in file to write to.
! 425: ** nByte -> Number of bytes of data to write (pointed to by zBuf).
! 426: **
! 427: ** ASYNC_SYNC:
! 428: ** nByte -> flags to pass to sqlite3OsSync().
! 429: **
! 430: ** ASYNC_TRUNCATE:
! 431: ** iOffset -> Size to truncate file to.
! 432: ** nByte -> Unused.
! 433: **
! 434: ** ASYNC_CLOSE:
! 435: ** iOffset -> Unused.
! 436: ** nByte -> Unused.
! 437: **
! 438: ** ASYNC_DELETE:
! 439: ** iOffset -> Contains the "syncDir" flag.
! 440: ** nByte -> Number of bytes of zBuf points to (file name).
! 441: **
! 442: ** ASYNC_OPENEXCLUSIVE:
! 443: ** iOffset -> Value of "delflag".
! 444: ** nByte -> Number of bytes of zBuf points to (file name).
! 445: **
! 446: ** ASYNC_UNLOCK:
! 447: ** nByte -> Argument to sqlite3OsUnlock().
! 448: **
! 449: **
! 450: ** For an ASYNC_WRITE operation, zBuf points to the data to write to the file.
! 451: ** This space is sqlite3_malloc()d along with the AsyncWrite structure in a
! 452: ** single blob, so is deleted when sqlite3_free() is called on the parent
! 453: ** structure.
! 454: */
! 455: struct AsyncWrite {
! 456: AsyncFileData *pFileData; /* File to write data to or sync */
! 457: int op; /* One of ASYNC_xxx etc. */
! 458: sqlite_int64 iOffset; /* See above */
! 459: int nByte; /* See above */
! 460: char *zBuf; /* Data to write to file (or NULL if op!=ASYNC_WRITE) */
! 461: AsyncWrite *pNext; /* Next write operation (to any file) */
! 462: };
! 463:
! 464: /*
! 465: ** An instance of this structure is created for each distinct open file
! 466: ** (i.e. if two handles are opened on the one file, only one of these
! 467: ** structures is allocated) and stored in the async.aLock hash table. The
! 468: ** keys for async.aLock are the full pathnames of the opened files.
! 469: **
! 470: ** AsyncLock.pList points to the head of a linked list of AsyncFileLock
! 471: ** structures, one for each handle currently open on the file.
! 472: **
! 473: ** If the opened file is not a main-database (the SQLITE_OPEN_MAIN_DB is
! 474: ** not passed to the sqlite3OsOpen() call), or if async.bLockFiles is
! 475: ** false, variables AsyncLock.pFile and AsyncLock.eLock are never used.
! 476: ** Otherwise, pFile is a file handle opened on the file in question and
! 477: ** used to obtain the file-system locks required by database connections
! 478: ** within this process.
! 479: **
! 480: ** See comments above the asyncLock() function for more details on
! 481: ** the implementation of database locking used by this backend.
! 482: */
! 483: struct AsyncLock {
! 484: char *zFile;
! 485: int nFile;
! 486: sqlite3_file *pFile;
! 487: int eLock;
! 488: AsyncFileLock *pList;
! 489: AsyncLock *pNext; /* Next in linked list headed by async.pLock */
! 490: };
! 491:
! 492: /*
! 493: ** An instance of the following structure is allocated along with each
! 494: ** AsyncFileData structure (see AsyncFileData.lock), but is only used if the
! 495: ** file was opened with the SQLITE_OPEN_MAIN_DB.
! 496: */
! 497: struct AsyncFileLock {
! 498: int eLock; /* Internally visible lock state (sqlite pov) */
! 499: int eAsyncLock; /* Lock-state with write-queue unlock */
! 500: AsyncFileLock *pNext;
! 501: };
! 502:
! 503: /*
! 504: ** The AsyncFile structure is a subclass of sqlite3_file used for
! 505: ** asynchronous IO.
! 506: **
! 507: ** All of the actual data for the structure is stored in the structure
! 508: ** pointed to by AsyncFile.pData, which is allocated as part of the
! 509: ** sqlite3OsOpen() using sqlite3_malloc(). The reason for this is that the
! 510: ** lifetime of the AsyncFile structure is ended by the caller after OsClose()
! 511: ** is called, but the data in AsyncFileData may be required by the
! 512: ** writer thread after that point.
! 513: */
! 514: struct AsyncFile {
! 515: sqlite3_io_methods *pMethod;
! 516: AsyncFileData *pData;
! 517: };
! 518: struct AsyncFileData {
! 519: char *zName; /* Underlying OS filename - used for debugging */
! 520: int nName; /* Number of characters in zName */
! 521: sqlite3_file *pBaseRead; /* Read handle to the underlying Os file */
! 522: sqlite3_file *pBaseWrite; /* Write handle to the underlying Os file */
! 523: AsyncFileLock lock; /* Lock state for this handle */
! 524: AsyncLock *pLock; /* AsyncLock object for this file system entry */
! 525: AsyncWrite closeOp; /* Preallocated close operation */
! 526: };
! 527:
! 528: /*
! 529: ** Add an entry to the end of the global write-op list. pWrite should point
! 530: ** to an AsyncWrite structure allocated using sqlite3_malloc(). The writer
! 531: ** thread will call sqlite3_free() to free the structure after the specified
! 532: ** operation has been completed.
! 533: **
! 534: ** Once an AsyncWrite structure has been added to the list, it becomes the
! 535: ** property of the writer thread and must not be read or modified by the
! 536: ** caller.
! 537: */
! 538: static void addAsyncWrite(AsyncWrite *pWrite){
! 539: /* We must hold the queue mutex in order to modify the queue pointers */
! 540: if( pWrite->op!=ASYNC_UNLOCK ){
! 541: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 542: }
! 543:
! 544: /* Add the record to the end of the write-op queue */
! 545: assert( !pWrite->pNext );
! 546: if( async.pQueueLast ){
! 547: assert( async.pQueueFirst );
! 548: async.pQueueLast->pNext = pWrite;
! 549: }else{
! 550: async.pQueueFirst = pWrite;
! 551: }
! 552: async.pQueueLast = pWrite;
! 553: ASYNC_TRACE(("PUSH %p (%s %s %d)\n", pWrite, azOpcodeName[pWrite->op],
! 554: pWrite->pFileData ? pWrite->pFileData->zName : "-", pWrite->iOffset));
! 555:
! 556: if( pWrite->op==ASYNC_CLOSE ){
! 557: async.nFile--;
! 558: }
! 559:
! 560: /* The writer thread might have been idle because there was nothing
! 561: ** on the write-op queue for it to do. So wake it up. */
! 562: async_cond_signal(ASYNC_COND_QUEUE);
! 563:
! 564: /* Drop the queue mutex */
! 565: if( pWrite->op!=ASYNC_UNLOCK ){
! 566: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 567: }
! 568: }
! 569:
! 570: /*
! 571: ** Increment async.nFile in a thread-safe manner.
! 572: */
! 573: static void incrOpenFileCount(void){
! 574: /* We must hold the queue mutex in order to modify async.nFile */
! 575: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 576: if( async.nFile==0 ){
! 577: async.ioError = SQLITE_OK;
! 578: }
! 579: async.nFile++;
! 580: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 581: }
! 582:
! 583: /*
! 584: ** This is a utility function to allocate and populate a new AsyncWrite
! 585: ** structure and insert it (via addAsyncWrite() ) into the global list.
! 586: */
! 587: static int addNewAsyncWrite(
! 588: AsyncFileData *pFileData,
! 589: int op,
! 590: sqlite3_int64 iOffset,
! 591: int nByte,
! 592: const char *zByte
! 593: ){
! 594: AsyncWrite *p;
! 595: if( op!=ASYNC_CLOSE && async.ioError ){
! 596: return async.ioError;
! 597: }
! 598: p = sqlite3_malloc(sizeof(AsyncWrite) + (zByte?nByte:0));
! 599: if( !p ){
! 600: /* The upper layer does not expect operations like OsWrite() to
! 601: ** return SQLITE_NOMEM. This is partly because under normal conditions
! 602: ** SQLite is required to do rollback without calling malloc(). So
! 603: ** if malloc() fails here, treat it as an I/O error. The above
! 604: ** layer knows how to handle that.
! 605: */
! 606: return SQLITE_IOERR;
! 607: }
! 608: p->op = op;
! 609: p->iOffset = iOffset;
! 610: p->nByte = nByte;
! 611: p->pFileData = pFileData;
! 612: p->pNext = 0;
! 613: if( zByte ){
! 614: p->zBuf = (char *)&p[1];
! 615: memcpy(p->zBuf, zByte, nByte);
! 616: }else{
! 617: p->zBuf = 0;
! 618: }
! 619: addAsyncWrite(p);
! 620: return SQLITE_OK;
! 621: }
! 622:
! 623: /*
! 624: ** Close the file. This just adds an entry to the write-op list, the file is
! 625: ** not actually closed.
! 626: */
! 627: static int asyncClose(sqlite3_file *pFile){
! 628: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 629:
! 630: /* Unlock the file, if it is locked */
! 631: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 632: p->lock.eLock = 0;
! 633: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 634:
! 635: addAsyncWrite(&p->closeOp);
! 636: return SQLITE_OK;
! 637: }
! 638:
! 639: /*
! 640: ** Implementation of sqlite3OsWrite() for asynchronous files. Instead of
! 641: ** writing to the underlying file, this function adds an entry to the end of
! 642: ** the global AsyncWrite list. Either SQLITE_OK or SQLITE_NOMEM may be
! 643: ** returned.
! 644: */
! 645: static int asyncWrite(
! 646: sqlite3_file *pFile,
! 647: const void *pBuf,
! 648: int amt,
! 649: sqlite3_int64 iOff
! 650: ){
! 651: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 652: return addNewAsyncWrite(p, ASYNC_WRITE, iOff, amt, pBuf);
! 653: }
! 654:
! 655: /*
! 656: ** Read data from the file. First we read from the filesystem, then adjust
! 657: ** the contents of the buffer based on ASYNC_WRITE operations in the
! 658: ** write-op queue.
! 659: **
! 660: ** This method holds the mutex from start to finish.
! 661: */
! 662: static int asyncRead(
! 663: sqlite3_file *pFile,
! 664: void *zOut,
! 665: int iAmt,
! 666: sqlite3_int64 iOffset
! 667: ){
! 668: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 669: int rc = SQLITE_OK;
! 670: sqlite3_int64 filesize = 0;
! 671: sqlite3_file *pBase = p->pBaseRead;
! 672: sqlite3_int64 iAmt64 = (sqlite3_int64)iAmt;
! 673:
! 674: /* Grab the write queue mutex for the duration of the call */
! 675: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 676:
! 677: /* If an I/O error has previously occurred in this virtual file
! 678: ** system, then all subsequent operations fail.
! 679: */
! 680: if( async.ioError!=SQLITE_OK ){
! 681: rc = async.ioError;
! 682: goto asyncread_out;
! 683: }
! 684:
! 685: if( pBase->pMethods ){
! 686: sqlite3_int64 nRead;
! 687: rc = pBase->pMethods->xFileSize(pBase, &filesize);
! 688: if( rc!=SQLITE_OK ){
! 689: goto asyncread_out;
! 690: }
! 691: nRead = MIN(filesize - iOffset, iAmt64);
! 692: if( nRead>0 ){
! 693: rc = pBase->pMethods->xRead(pBase, zOut, (int)nRead, iOffset);
! 694: ASYNC_TRACE(("READ %s %d bytes at %d\n", p->zName, nRead, iOffset));
! 695: }
! 696: }
! 697:
! 698: if( rc==SQLITE_OK ){
! 699: AsyncWrite *pWrite;
! 700: char *zName = p->zName;
! 701:
! 702: for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){
! 703: if( pWrite->op==ASYNC_WRITE && (
! 704: (pWrite->pFileData==p) ||
! 705: (zName && pWrite->pFileData->zName==zName)
! 706: )){
! 707: sqlite3_int64 nCopy;
! 708: sqlite3_int64 nByte64 = (sqlite3_int64)pWrite->nByte;
! 709:
! 710: /* Set variable iBeginIn to the offset in buffer pWrite->zBuf[] from
! 711: ** which data should be copied. Set iBeginOut to the offset within
! 712: ** the output buffer to which data should be copied. If either of
! 713: ** these offsets is a negative number, set them to 0.
! 714: */
! 715: sqlite3_int64 iBeginOut = (pWrite->iOffset-iOffset);
! 716: sqlite3_int64 iBeginIn = -iBeginOut;
! 717: if( iBeginIn<0 ) iBeginIn = 0;
! 718: if( iBeginOut<0 ) iBeginOut = 0;
! 719:
! 720: filesize = MAX(filesize, pWrite->iOffset+nByte64);
! 721:
! 722: nCopy = MIN(nByte64-iBeginIn, iAmt64-iBeginOut);
! 723: if( nCopy>0 ){
! 724: memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], (size_t)nCopy);
! 725: ASYNC_TRACE(("OVERREAD %d bytes at %d\n", nCopy, iBeginOut+iOffset));
! 726: }
! 727: }
! 728: }
! 729: }
! 730:
! 731: asyncread_out:
! 732: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 733: if( rc==SQLITE_OK && filesize<(iOffset+iAmt) ){
! 734: rc = SQLITE_IOERR_SHORT_READ;
! 735: }
! 736: return rc;
! 737: }
! 738:
! 739: /*
! 740: ** Truncate the file to nByte bytes in length. This just adds an entry to
! 741: ** the write-op list, no IO actually takes place.
! 742: */
! 743: static int asyncTruncate(sqlite3_file *pFile, sqlite3_int64 nByte){
! 744: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 745: return addNewAsyncWrite(p, ASYNC_TRUNCATE, nByte, 0, 0);
! 746: }
! 747:
! 748: /*
! 749: ** Sync the file. This just adds an entry to the write-op list, the
! 750: ** sync() is done later by sqlite3_async_flush().
! 751: */
! 752: static int asyncSync(sqlite3_file *pFile, int flags){
! 753: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 754: return addNewAsyncWrite(p, ASYNC_SYNC, 0, flags, 0);
! 755: }
! 756:
! 757: /*
! 758: ** Read the size of the file. First we read the size of the file system
! 759: ** entry, then adjust for any ASYNC_WRITE or ASYNC_TRUNCATE operations
! 760: ** currently in the write-op list.
! 761: **
! 762: ** This method holds the mutex from start to finish.
! 763: */
! 764: int asyncFileSize(sqlite3_file *pFile, sqlite3_int64 *piSize){
! 765: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 766: int rc = SQLITE_OK;
! 767: sqlite3_int64 s = 0;
! 768: sqlite3_file *pBase;
! 769:
! 770: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 771:
! 772: /* Read the filesystem size from the base file. If pMethods is NULL, this
! 773: ** means the file hasn't been opened yet. In this case all relevant data
! 774: ** must be in the write-op queue anyway, so we can omit reading from the
! 775: ** file-system.
! 776: */
! 777: pBase = p->pBaseRead;
! 778: if( pBase->pMethods ){
! 779: rc = pBase->pMethods->xFileSize(pBase, &s);
! 780: }
! 781:
! 782: if( rc==SQLITE_OK ){
! 783: AsyncWrite *pWrite;
! 784: for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){
! 785: if( pWrite->op==ASYNC_DELETE
! 786: && p->zName
! 787: && strcmp(p->zName, pWrite->zBuf)==0
! 788: ){
! 789: s = 0;
! 790: }else if( pWrite->pFileData && (
! 791: (pWrite->pFileData==p)
! 792: || (p->zName && pWrite->pFileData->zName==p->zName)
! 793: )){
! 794: switch( pWrite->op ){
! 795: case ASYNC_WRITE:
! 796: s = MAX(pWrite->iOffset + (sqlite3_int64)(pWrite->nByte), s);
! 797: break;
! 798: case ASYNC_TRUNCATE:
! 799: s = MIN(s, pWrite->iOffset);
! 800: break;
! 801: }
! 802: }
! 803: }
! 804: *piSize = s;
! 805: }
! 806: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 807: return rc;
! 808: }
! 809:
! 810: /*
! 811: ** Lock or unlock the actual file-system entry.
! 812: */
! 813: static int getFileLock(AsyncLock *pLock){
! 814: int rc = SQLITE_OK;
! 815: AsyncFileLock *pIter;
! 816: int eRequired = 0;
! 817:
! 818: if( pLock->pFile ){
! 819: for(pIter=pLock->pList; pIter; pIter=pIter->pNext){
! 820: assert(pIter->eAsyncLock>=pIter->eLock);
! 821: if( pIter->eAsyncLock>eRequired ){
! 822: eRequired = pIter->eAsyncLock;
! 823: assert(eRequired>=0 && eRequired<=SQLITE_LOCK_EXCLUSIVE);
! 824: }
! 825: }
! 826:
! 827: if( eRequired>pLock->eLock ){
! 828: rc = pLock->pFile->pMethods->xLock(pLock->pFile, eRequired);
! 829: if( rc==SQLITE_OK ){
! 830: pLock->eLock = eRequired;
! 831: }
! 832: }
! 833: else if( eRequired<pLock->eLock && eRequired<=SQLITE_LOCK_SHARED ){
! 834: rc = pLock->pFile->pMethods->xUnlock(pLock->pFile, eRequired);
! 835: if( rc==SQLITE_OK ){
! 836: pLock->eLock = eRequired;
! 837: }
! 838: }
! 839: }
! 840:
! 841: return rc;
! 842: }
! 843:
! 844: /*
! 845: ** Return the AsyncLock structure from the global async.pLock list
! 846: ** associated with the file-system entry identified by path zName
! 847: ** (a string of nName bytes). If no such structure exists, return 0.
! 848: */
! 849: static AsyncLock *findLock(const char *zName, int nName){
! 850: AsyncLock *p = async.pLock;
! 851: while( p && (p->nFile!=nName || memcmp(p->zFile, zName, nName)) ){
! 852: p = p->pNext;
! 853: }
! 854: return p;
! 855: }
! 856:
! 857: /*
! 858: ** The following two methods - asyncLock() and asyncUnlock() - are used
! 859: ** to obtain and release locks on database files opened with the
! 860: ** asynchronous backend.
! 861: */
! 862: static int asyncLock(sqlite3_file *pFile, int eLock){
! 863: int rc = SQLITE_OK;
! 864: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 865:
! 866: if( p->zName ){
! 867: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 868: if( p->lock.eLock<eLock ){
! 869: AsyncLock *pLock = p->pLock;
! 870: AsyncFileLock *pIter;
! 871: assert(pLock && pLock->pList);
! 872: for(pIter=pLock->pList; pIter; pIter=pIter->pNext){
! 873: if( pIter!=&p->lock && (
! 874: (eLock==SQLITE_LOCK_EXCLUSIVE && pIter->eLock>=SQLITE_LOCK_SHARED) ||
! 875: (eLock==SQLITE_LOCK_PENDING && pIter->eLock>=SQLITE_LOCK_RESERVED) ||
! 876: (eLock==SQLITE_LOCK_RESERVED && pIter->eLock>=SQLITE_LOCK_RESERVED) ||
! 877: (eLock==SQLITE_LOCK_SHARED && pIter->eLock>=SQLITE_LOCK_PENDING)
! 878: )){
! 879: rc = SQLITE_BUSY;
! 880: }
! 881: }
! 882: if( rc==SQLITE_OK ){
! 883: p->lock.eLock = eLock;
! 884: p->lock.eAsyncLock = MAX(p->lock.eAsyncLock, eLock);
! 885: }
! 886: assert(p->lock.eAsyncLock>=p->lock.eLock);
! 887: if( rc==SQLITE_OK ){
! 888: rc = getFileLock(pLock);
! 889: }
! 890: }
! 891: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 892: }
! 893:
! 894: ASYNC_TRACE(("LOCK %d (%s) rc=%d\n", eLock, p->zName, rc));
! 895: return rc;
! 896: }
! 897: static int asyncUnlock(sqlite3_file *pFile, int eLock){
! 898: int rc = SQLITE_OK;
! 899: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 900: if( p->zName ){
! 901: AsyncFileLock *pLock = &p->lock;
! 902: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 903: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 904: pLock->eLock = MIN(pLock->eLock, eLock);
! 905: rc = addNewAsyncWrite(p, ASYNC_UNLOCK, 0, eLock, 0);
! 906: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 907: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 908: }
! 909: return rc;
! 910: }
! 911:
! 912: /*
! 913: ** This function is called when the pager layer first opens a database file
! 914: ** and is checking for a hot-journal.
! 915: */
! 916: static int asyncCheckReservedLock(sqlite3_file *pFile, int *pResOut){
! 917: int ret = 0;
! 918: AsyncFileLock *pIter;
! 919: AsyncFileData *p = ((AsyncFile *)pFile)->pData;
! 920:
! 921: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 922: for(pIter=p->pLock->pList; pIter; pIter=pIter->pNext){
! 923: if( pIter->eLock>=SQLITE_LOCK_RESERVED ){
! 924: ret = 1;
! 925: break;
! 926: }
! 927: }
! 928: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 929:
! 930: ASYNC_TRACE(("CHECK-LOCK %d (%s)\n", ret, p->zName));
! 931: *pResOut = ret;
! 932: return SQLITE_OK;
! 933: }
! 934:
! 935: /*
! 936: ** sqlite3_file_control() implementation.
! 937: */
! 938: static int asyncFileControl(sqlite3_file *id, int op, void *pArg){
! 939: switch( op ){
! 940: case SQLITE_FCNTL_LOCKSTATE: {
! 941: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 942: *(int*)pArg = ((AsyncFile*)id)->pData->lock.eLock;
! 943: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 944: return SQLITE_OK;
! 945: }
! 946: }
! 947: return SQLITE_ERROR;
! 948: }
! 949:
! 950: /*
! 951: ** Return the device characteristics and sector-size of the device. It
! 952: ** is tricky to implement these correctly, as this backend might
! 953: ** not have an open file handle at this point.
! 954: */
! 955: static int asyncSectorSize(sqlite3_file *pFile){
! 956: UNUSED_PARAMETER(pFile);
! 957: return 512;
! 958: }
! 959: static int asyncDeviceCharacteristics(sqlite3_file *pFile){
! 960: UNUSED_PARAMETER(pFile);
! 961: return 0;
! 962: }
! 963:
! 964: static int unlinkAsyncFile(AsyncFileData *pData){
! 965: AsyncFileLock **ppIter;
! 966: int rc = SQLITE_OK;
! 967:
! 968: if( pData->zName ){
! 969: AsyncLock *pLock = pData->pLock;
! 970: for(ppIter=&pLock->pList; *ppIter; ppIter=&((*ppIter)->pNext)){
! 971: if( (*ppIter)==&pData->lock ){
! 972: *ppIter = pData->lock.pNext;
! 973: break;
! 974: }
! 975: }
! 976: if( !pLock->pList ){
! 977: AsyncLock **pp;
! 978: if( pLock->pFile ){
! 979: pLock->pFile->pMethods->xClose(pLock->pFile);
! 980: }
! 981: for(pp=&async.pLock; *pp!=pLock; pp=&((*pp)->pNext));
! 982: *pp = pLock->pNext;
! 983: sqlite3_free(pLock);
! 984: }else{
! 985: rc = getFileLock(pLock);
! 986: }
! 987: }
! 988:
! 989: return rc;
! 990: }
! 991:
! 992: /*
! 993: ** The parameter passed to this function is a copy of a 'flags' parameter
! 994: ** passed to this modules xOpen() method. This function returns true
! 995: ** if the file should be opened asynchronously, or false if it should
! 996: ** be opened immediately.
! 997: **
! 998: ** If the file is to be opened asynchronously, then asyncOpen() will add
! 999: ** an entry to the event queue and the file will not actually be opened
! 1000: ** until the event is processed. Otherwise, the file is opened directly
! 1001: ** by the caller.
! 1002: */
! 1003: static int doAsynchronousOpen(int flags){
! 1004: return (flags&SQLITE_OPEN_CREATE) && (
! 1005: (flags&SQLITE_OPEN_MAIN_JOURNAL) ||
! 1006: (flags&SQLITE_OPEN_TEMP_JOURNAL) ||
! 1007: (flags&SQLITE_OPEN_DELETEONCLOSE)
! 1008: );
! 1009: }
! 1010:
! 1011: /*
! 1012: ** Open a file.
! 1013: */
! 1014: static int asyncOpen(
! 1015: sqlite3_vfs *pAsyncVfs,
! 1016: const char *zName,
! 1017: sqlite3_file *pFile,
! 1018: int flags,
! 1019: int *pOutFlags
! 1020: ){
! 1021: static sqlite3_io_methods async_methods = {
! 1022: 1, /* iVersion */
! 1023: asyncClose, /* xClose */
! 1024: asyncRead, /* xRead */
! 1025: asyncWrite, /* xWrite */
! 1026: asyncTruncate, /* xTruncate */
! 1027: asyncSync, /* xSync */
! 1028: asyncFileSize, /* xFileSize */
! 1029: asyncLock, /* xLock */
! 1030: asyncUnlock, /* xUnlock */
! 1031: asyncCheckReservedLock, /* xCheckReservedLock */
! 1032: asyncFileControl, /* xFileControl */
! 1033: asyncSectorSize, /* xSectorSize */
! 1034: asyncDeviceCharacteristics /* xDeviceCharacteristics */
! 1035: };
! 1036:
! 1037: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1038: AsyncFile *p = (AsyncFile *)pFile;
! 1039: int nName = 0;
! 1040: int rc = SQLITE_OK;
! 1041: int nByte;
! 1042: AsyncFileData *pData;
! 1043: AsyncLock *pLock = 0;
! 1044: char *z;
! 1045: int isAsyncOpen = doAsynchronousOpen(flags);
! 1046:
! 1047: /* If zName is NULL, then the upper layer is requesting an anonymous file */
! 1048: if( zName ){
! 1049: nName = (int)strlen(zName)+1;
! 1050: }
! 1051:
! 1052: nByte = (
! 1053: sizeof(AsyncFileData) + /* AsyncFileData structure */
! 1054: 2 * pVfs->szOsFile + /* AsyncFileData.pBaseRead and pBaseWrite */
! 1055: nName /* AsyncFileData.zName */
! 1056: );
! 1057: z = sqlite3_malloc(nByte);
! 1058: if( !z ){
! 1059: return SQLITE_NOMEM;
! 1060: }
! 1061: memset(z, 0, nByte);
! 1062: pData = (AsyncFileData*)z;
! 1063: z += sizeof(pData[0]);
! 1064: pData->pBaseRead = (sqlite3_file*)z;
! 1065: z += pVfs->szOsFile;
! 1066: pData->pBaseWrite = (sqlite3_file*)z;
! 1067: pData->closeOp.pFileData = pData;
! 1068: pData->closeOp.op = ASYNC_CLOSE;
! 1069:
! 1070: if( zName ){
! 1071: z += pVfs->szOsFile;
! 1072: pData->zName = z;
! 1073: pData->nName = nName;
! 1074: memcpy(pData->zName, zName, nName);
! 1075: }
! 1076:
! 1077: if( !isAsyncOpen ){
! 1078: int flagsout;
! 1079: rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseRead, flags, &flagsout);
! 1080: if( rc==SQLITE_OK
! 1081: && (flagsout&SQLITE_OPEN_READWRITE)
! 1082: && (flags&SQLITE_OPEN_EXCLUSIVE)==0
! 1083: ){
! 1084: rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseWrite, flags, 0);
! 1085: }
! 1086: if( pOutFlags ){
! 1087: *pOutFlags = flagsout;
! 1088: }
! 1089: }
! 1090:
! 1091: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 1092:
! 1093: if( zName && rc==SQLITE_OK ){
! 1094: pLock = findLock(pData->zName, pData->nName);
! 1095: if( !pLock ){
! 1096: int nByte = pVfs->szOsFile + sizeof(AsyncLock) + pData->nName + 1;
! 1097: pLock = (AsyncLock *)sqlite3_malloc(nByte);
! 1098: if( pLock ){
! 1099: memset(pLock, 0, nByte);
! 1100: if( async.bLockFiles && (flags&SQLITE_OPEN_MAIN_DB) ){
! 1101: pLock->pFile = (sqlite3_file *)&pLock[1];
! 1102: rc = pVfs->xOpen(pVfs, pData->zName, pLock->pFile, flags, 0);
! 1103: if( rc!=SQLITE_OK ){
! 1104: sqlite3_free(pLock);
! 1105: pLock = 0;
! 1106: }
! 1107: }
! 1108: if( pLock ){
! 1109: pLock->nFile = pData->nName;
! 1110: pLock->zFile = &((char *)(&pLock[1]))[pVfs->szOsFile];
! 1111: memcpy(pLock->zFile, pData->zName, pLock->nFile);
! 1112: pLock->pNext = async.pLock;
! 1113: async.pLock = pLock;
! 1114: }
! 1115: }else{
! 1116: rc = SQLITE_NOMEM;
! 1117: }
! 1118: }
! 1119: }
! 1120:
! 1121: if( rc==SQLITE_OK ){
! 1122: p->pMethod = &async_methods;
! 1123: p->pData = pData;
! 1124:
! 1125: /* Link AsyncFileData.lock into the linked list of
! 1126: ** AsyncFileLock structures for this file.
! 1127: */
! 1128: if( zName ){
! 1129: pData->lock.pNext = pLock->pList;
! 1130: pLock->pList = &pData->lock;
! 1131: pData->zName = pLock->zFile;
! 1132: }
! 1133: }else{
! 1134: if( pData->pBaseRead->pMethods ){
! 1135: pData->pBaseRead->pMethods->xClose(pData->pBaseRead);
! 1136: }
! 1137: if( pData->pBaseWrite->pMethods ){
! 1138: pData->pBaseWrite->pMethods->xClose(pData->pBaseWrite);
! 1139: }
! 1140: sqlite3_free(pData);
! 1141: }
! 1142:
! 1143: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 1144:
! 1145: if( rc==SQLITE_OK ){
! 1146: pData->pLock = pLock;
! 1147: }
! 1148:
! 1149: if( rc==SQLITE_OK && isAsyncOpen ){
! 1150: rc = addNewAsyncWrite(pData, ASYNC_OPENEXCLUSIVE, (sqlite3_int64)flags,0,0);
! 1151: if( rc==SQLITE_OK ){
! 1152: if( pOutFlags ) *pOutFlags = flags;
! 1153: }else{
! 1154: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 1155: unlinkAsyncFile(pData);
! 1156: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 1157: sqlite3_free(pData);
! 1158: }
! 1159: }
! 1160: if( rc!=SQLITE_OK ){
! 1161: p->pMethod = 0;
! 1162: }else{
! 1163: incrOpenFileCount();
! 1164: }
! 1165:
! 1166: return rc;
! 1167: }
! 1168:
! 1169: /*
! 1170: ** Implementation of sqlite3OsDelete. Add an entry to the end of the
! 1171: ** write-op queue to perform the delete.
! 1172: */
! 1173: static int asyncDelete(sqlite3_vfs *pAsyncVfs, const char *z, int syncDir){
! 1174: UNUSED_PARAMETER(pAsyncVfs);
! 1175: return addNewAsyncWrite(0, ASYNC_DELETE, syncDir, (int)strlen(z)+1, z);
! 1176: }
! 1177:
! 1178: /*
! 1179: ** Implementation of sqlite3OsAccess. This method holds the mutex from
! 1180: ** start to finish.
! 1181: */
! 1182: static int asyncAccess(
! 1183: sqlite3_vfs *pAsyncVfs,
! 1184: const char *zName,
! 1185: int flags,
! 1186: int *pResOut
! 1187: ){
! 1188: int rc;
! 1189: int ret;
! 1190: AsyncWrite *p;
! 1191: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1192:
! 1193: assert(flags==SQLITE_ACCESS_READWRITE
! 1194: || flags==SQLITE_ACCESS_READ
! 1195: || flags==SQLITE_ACCESS_EXISTS
! 1196: );
! 1197:
! 1198: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1199: rc = pVfs->xAccess(pVfs, zName, flags, &ret);
! 1200: if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
! 1201: for(p=async.pQueueFirst; p; p = p->pNext){
! 1202: if( p->op==ASYNC_DELETE && 0==strcmp(p->zBuf, zName) ){
! 1203: ret = 0;
! 1204: }else if( p->op==ASYNC_OPENEXCLUSIVE
! 1205: && p->pFileData->zName
! 1206: && 0==strcmp(p->pFileData->zName, zName)
! 1207: ){
! 1208: ret = 1;
! 1209: }
! 1210: }
! 1211: }
! 1212: ASYNC_TRACE(("ACCESS(%s): %s = %d\n",
! 1213: flags==SQLITE_ACCESS_READWRITE?"read-write":
! 1214: flags==SQLITE_ACCESS_READ?"read":"exists"
! 1215: , zName, ret)
! 1216: );
! 1217: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1218: *pResOut = ret;
! 1219: return rc;
! 1220: }
! 1221:
! 1222: /*
! 1223: ** Fill in zPathOut with the full path to the file identified by zPath.
! 1224: */
! 1225: static int asyncFullPathname(
! 1226: sqlite3_vfs *pAsyncVfs,
! 1227: const char *zPath,
! 1228: int nPathOut,
! 1229: char *zPathOut
! 1230: ){
! 1231: int rc;
! 1232: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1233: rc = pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
! 1234:
! 1235: /* Because of the way intra-process file locking works, this backend
! 1236: ** needs to return a canonical path. The following block assumes the
! 1237: ** file-system uses unix style paths.
! 1238: */
! 1239: if( rc==SQLITE_OK ){
! 1240: int i, j;
! 1241: char *z = zPathOut;
! 1242: int n = (int)strlen(z);
! 1243: while( n>1 && z[n-1]=='/' ){ n--; }
! 1244: for(i=j=0; i<n; i++){
! 1245: if( z[i]=='/' ){
! 1246: if( z[i+1]=='/' ) continue;
! 1247: if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
! 1248: i += 1;
! 1249: continue;
! 1250: }
! 1251: if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
! 1252: while( j>0 && z[j-1]!='/' ){ j--; }
! 1253: if( j>0 ){ j--; }
! 1254: i += 2;
! 1255: continue;
! 1256: }
! 1257: }
! 1258: z[j++] = z[i];
! 1259: }
! 1260: z[j] = 0;
! 1261: }
! 1262:
! 1263: return rc;
! 1264: }
! 1265: static void *asyncDlOpen(sqlite3_vfs *pAsyncVfs, const char *zPath){
! 1266: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1267: return pVfs->xDlOpen(pVfs, zPath);
! 1268: }
! 1269: static void asyncDlError(sqlite3_vfs *pAsyncVfs, int nByte, char *zErrMsg){
! 1270: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1271: pVfs->xDlError(pVfs, nByte, zErrMsg);
! 1272: }
! 1273: static void (*asyncDlSym(
! 1274: sqlite3_vfs *pAsyncVfs,
! 1275: void *pHandle,
! 1276: const char *zSymbol
! 1277: ))(void){
! 1278: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1279: return pVfs->xDlSym(pVfs, pHandle, zSymbol);
! 1280: }
! 1281: static void asyncDlClose(sqlite3_vfs *pAsyncVfs, void *pHandle){
! 1282: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1283: pVfs->xDlClose(pVfs, pHandle);
! 1284: }
! 1285: static int asyncRandomness(sqlite3_vfs *pAsyncVfs, int nByte, char *zBufOut){
! 1286: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1287: return pVfs->xRandomness(pVfs, nByte, zBufOut);
! 1288: }
! 1289: static int asyncSleep(sqlite3_vfs *pAsyncVfs, int nMicro){
! 1290: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1291: return pVfs->xSleep(pVfs, nMicro);
! 1292: }
! 1293: static int asyncCurrentTime(sqlite3_vfs *pAsyncVfs, double *pTimeOut){
! 1294: sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
! 1295: return pVfs->xCurrentTime(pVfs, pTimeOut);
! 1296: }
! 1297:
! 1298: static sqlite3_vfs async_vfs = {
! 1299: 1, /* iVersion */
! 1300: sizeof(AsyncFile), /* szOsFile */
! 1301: 0, /* mxPathname */
! 1302: 0, /* pNext */
! 1303: SQLITEASYNC_VFSNAME, /* zName */
! 1304: 0, /* pAppData */
! 1305: asyncOpen, /* xOpen */
! 1306: asyncDelete, /* xDelete */
! 1307: asyncAccess, /* xAccess */
! 1308: asyncFullPathname, /* xFullPathname */
! 1309: asyncDlOpen, /* xDlOpen */
! 1310: asyncDlError, /* xDlError */
! 1311: asyncDlSym, /* xDlSym */
! 1312: asyncDlClose, /* xDlClose */
! 1313: asyncRandomness, /* xDlError */
! 1314: asyncSleep, /* xDlSym */
! 1315: asyncCurrentTime /* xDlClose */
! 1316: };
! 1317:
! 1318: /*
! 1319: ** This procedure runs in a separate thread, reading messages off of the
! 1320: ** write queue and processing them one by one.
! 1321: **
! 1322: ** If async.writerHaltNow is true, then this procedure exits
! 1323: ** after processing a single message.
! 1324: **
! 1325: ** If async.writerHaltWhenIdle is true, then this procedure exits when
! 1326: ** the write queue is empty.
! 1327: **
! 1328: ** If both of the above variables are false, this procedure runs
! 1329: ** indefinately, waiting for operations to be added to the write queue
! 1330: ** and processing them in the order in which they arrive.
! 1331: **
! 1332: ** An artifical delay of async.ioDelay milliseconds is inserted before
! 1333: ** each write operation in order to simulate the effect of a slow disk.
! 1334: **
! 1335: ** Only one instance of this procedure may be running at a time.
! 1336: */
! 1337: static void asyncWriterThread(void){
! 1338: sqlite3_vfs *pVfs = (sqlite3_vfs *)(async_vfs.pAppData);
! 1339: AsyncWrite *p = 0;
! 1340: int rc = SQLITE_OK;
! 1341: int holdingMutex = 0;
! 1342:
! 1343: async_mutex_enter(ASYNC_MUTEX_WRITER);
! 1344:
! 1345: while( async.eHalt!=SQLITEASYNC_HALT_NOW ){
! 1346: int doNotFree = 0;
! 1347: sqlite3_file *pBase = 0;
! 1348:
! 1349: if( !holdingMutex ){
! 1350: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1351: }
! 1352: while( (p = async.pQueueFirst)==0 ){
! 1353: if( async.eHalt!=SQLITEASYNC_HALT_NEVER ){
! 1354: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1355: break;
! 1356: }else{
! 1357: ASYNC_TRACE(("IDLE\n"));
! 1358: async_cond_wait(ASYNC_COND_QUEUE, ASYNC_MUTEX_QUEUE);
! 1359: ASYNC_TRACE(("WAKEUP\n"));
! 1360: }
! 1361: }
! 1362: if( p==0 ) break;
! 1363: holdingMutex = 1;
! 1364:
! 1365: /* Right now this thread is holding the mutex on the write-op queue.
! 1366: ** Variable 'p' points to the first entry in the write-op queue. In
! 1367: ** the general case, we hold on to the mutex for the entire body of
! 1368: ** the loop.
! 1369: **
! 1370: ** However in the cases enumerated below, we relinquish the mutex,
! 1371: ** perform the IO, and then re-request the mutex before removing 'p' from
! 1372: ** the head of the write-op queue. The idea is to increase concurrency with
! 1373: ** sqlite threads.
! 1374: **
! 1375: ** * An ASYNC_CLOSE operation.
! 1376: ** * An ASYNC_OPENEXCLUSIVE operation. For this one, we relinquish
! 1377: ** the mutex, call the underlying xOpenExclusive() function, then
! 1378: ** re-aquire the mutex before seting the AsyncFile.pBaseRead
! 1379: ** variable.
! 1380: ** * ASYNC_SYNC and ASYNC_WRITE operations, if
! 1381: ** SQLITE_ASYNC_TWO_FILEHANDLES was set at compile time and two
! 1382: ** file-handles are open for the particular file being "synced".
! 1383: */
! 1384: if( async.ioError!=SQLITE_OK && p->op!=ASYNC_CLOSE ){
! 1385: p->op = ASYNC_NOOP;
! 1386: }
! 1387: if( p->pFileData ){
! 1388: pBase = p->pFileData->pBaseWrite;
! 1389: if(
! 1390: p->op==ASYNC_CLOSE ||
! 1391: p->op==ASYNC_OPENEXCLUSIVE ||
! 1392: (pBase->pMethods && (p->op==ASYNC_SYNC || p->op==ASYNC_WRITE) )
! 1393: ){
! 1394: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1395: holdingMutex = 0;
! 1396: }
! 1397: if( !pBase->pMethods ){
! 1398: pBase = p->pFileData->pBaseRead;
! 1399: }
! 1400: }
! 1401:
! 1402: switch( p->op ){
! 1403: case ASYNC_NOOP:
! 1404: break;
! 1405:
! 1406: case ASYNC_WRITE:
! 1407: assert( pBase );
! 1408: ASYNC_TRACE(("WRITE %s %d bytes at %d\n",
! 1409: p->pFileData->zName, p->nByte, p->iOffset));
! 1410: rc = pBase->pMethods->xWrite(pBase, (void *)(p->zBuf), p->nByte, p->iOffset);
! 1411: break;
! 1412:
! 1413: case ASYNC_SYNC:
! 1414: assert( pBase );
! 1415: ASYNC_TRACE(("SYNC %s\n", p->pFileData->zName));
! 1416: rc = pBase->pMethods->xSync(pBase, p->nByte);
! 1417: break;
! 1418:
! 1419: case ASYNC_TRUNCATE:
! 1420: assert( pBase );
! 1421: ASYNC_TRACE(("TRUNCATE %s to %d bytes\n",
! 1422: p->pFileData->zName, p->iOffset));
! 1423: rc = pBase->pMethods->xTruncate(pBase, p->iOffset);
! 1424: break;
! 1425:
! 1426: case ASYNC_CLOSE: {
! 1427: AsyncFileData *pData = p->pFileData;
! 1428: ASYNC_TRACE(("CLOSE %s\n", p->pFileData->zName));
! 1429: if( pData->pBaseWrite->pMethods ){
! 1430: pData->pBaseWrite->pMethods->xClose(pData->pBaseWrite);
! 1431: }
! 1432: if( pData->pBaseRead->pMethods ){
! 1433: pData->pBaseRead->pMethods->xClose(pData->pBaseRead);
! 1434: }
! 1435:
! 1436: /* Unlink AsyncFileData.lock from the linked list of AsyncFileLock
! 1437: ** structures for this file. Obtain the async.lockMutex mutex
! 1438: ** before doing so.
! 1439: */
! 1440: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 1441: rc = unlinkAsyncFile(pData);
! 1442: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 1443:
! 1444: if( !holdingMutex ){
! 1445: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1446: holdingMutex = 1;
! 1447: }
! 1448: assert_mutex_is_held(ASYNC_MUTEX_QUEUE);
! 1449: async.pQueueFirst = p->pNext;
! 1450: sqlite3_free(pData);
! 1451: doNotFree = 1;
! 1452: break;
! 1453: }
! 1454:
! 1455: case ASYNC_UNLOCK: {
! 1456: AsyncWrite *pIter;
! 1457: AsyncFileData *pData = p->pFileData;
! 1458: int eLock = p->nByte;
! 1459:
! 1460: /* When a file is locked by SQLite using the async backend, it is
! 1461: ** locked within the 'real' file-system synchronously. When it is
! 1462: ** unlocked, an ASYNC_UNLOCK event is added to the write-queue to
! 1463: ** unlock the file asynchronously. The design of the async backend
! 1464: ** requires that the 'real' file-system file be locked from the
! 1465: ** time that SQLite first locks it (and probably reads from it)
! 1466: ** until all asynchronous write events that were scheduled before
! 1467: ** SQLite unlocked the file have been processed.
! 1468: **
! 1469: ** This is more complex if SQLite locks and unlocks the file multiple
! 1470: ** times in quick succession. For example, if SQLite does:
! 1471: **
! 1472: ** lock, write, unlock, lock, write, unlock
! 1473: **
! 1474: ** Each "lock" operation locks the file immediately. Each "write"
! 1475: ** and "unlock" operation adds an event to the event queue. If the
! 1476: ** second "lock" operation is performed before the first "unlock"
! 1477: ** operation has been processed asynchronously, then the first
! 1478: ** "unlock" cannot be safely processed as is, since this would mean
! 1479: ** the file was unlocked when the second "write" operation is
! 1480: ** processed. To work around this, when processing an ASYNC_UNLOCK
! 1481: ** operation, SQLite:
! 1482: **
! 1483: ** 1) Unlocks the file to the minimum of the argument passed to
! 1484: ** the xUnlock() call and the current lock from SQLite's point
! 1485: ** of view, and
! 1486: **
! 1487: ** 2) Only unlocks the file at all if this event is the last
! 1488: ** ASYNC_UNLOCK event on this file in the write-queue.
! 1489: */
! 1490: assert( holdingMutex==1 );
! 1491: assert( async.pQueueFirst==p );
! 1492: for(pIter=async.pQueueFirst->pNext; pIter; pIter=pIter->pNext){
! 1493: if( pIter->pFileData==pData && pIter->op==ASYNC_UNLOCK ) break;
! 1494: }
! 1495: if( !pIter ){
! 1496: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 1497: pData->lock.eAsyncLock = MIN(
! 1498: pData->lock.eAsyncLock, MAX(pData->lock.eLock, eLock)
! 1499: );
! 1500: assert(pData->lock.eAsyncLock>=pData->lock.eLock);
! 1501: rc = getFileLock(pData->pLock);
! 1502: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 1503: }
! 1504: break;
! 1505: }
! 1506:
! 1507: case ASYNC_DELETE:
! 1508: ASYNC_TRACE(("DELETE %s\n", p->zBuf));
! 1509: rc = pVfs->xDelete(pVfs, p->zBuf, (int)p->iOffset);
! 1510: break;
! 1511:
! 1512: case ASYNC_OPENEXCLUSIVE: {
! 1513: int flags = (int)p->iOffset;
! 1514: AsyncFileData *pData = p->pFileData;
! 1515: ASYNC_TRACE(("OPEN %s flags=%d\n", p->zBuf, (int)p->iOffset));
! 1516: assert(pData->pBaseRead->pMethods==0 && pData->pBaseWrite->pMethods==0);
! 1517: rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseRead, flags, 0);
! 1518: assert( holdingMutex==0 );
! 1519: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1520: holdingMutex = 1;
! 1521: break;
! 1522: }
! 1523:
! 1524: default: assert(!"Illegal value for AsyncWrite.op");
! 1525: }
! 1526:
! 1527: /* If we didn't hang on to the mutex during the IO op, obtain it now
! 1528: ** so that the AsyncWrite structure can be safely removed from the
! 1529: ** global write-op queue.
! 1530: */
! 1531: if( !holdingMutex ){
! 1532: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1533: holdingMutex = 1;
! 1534: }
! 1535: /* ASYNC_TRACE(("UNLINK %p\n", p)); */
! 1536: if( p==async.pQueueLast ){
! 1537: async.pQueueLast = 0;
! 1538: }
! 1539: if( !doNotFree ){
! 1540: assert_mutex_is_held(ASYNC_MUTEX_QUEUE);
! 1541: async.pQueueFirst = p->pNext;
! 1542: sqlite3_free(p);
! 1543: }
! 1544: assert( holdingMutex );
! 1545:
! 1546: /* An IO error has occurred. We cannot report the error back to the
! 1547: ** connection that requested the I/O since the error happened
! 1548: ** asynchronously. The connection has already moved on. There
! 1549: ** really is nobody to report the error to.
! 1550: **
! 1551: ** The file for which the error occurred may have been a database or
! 1552: ** journal file. Regardless, none of the currently queued operations
! 1553: ** associated with the same database should now be performed. Nor should
! 1554: ** any subsequently requested IO on either a database or journal file
! 1555: ** handle for the same database be accepted until the main database
! 1556: ** file handle has been closed and reopened.
! 1557: **
! 1558: ** Furthermore, no further IO should be queued or performed on any file
! 1559: ** handle associated with a database that may have been part of a
! 1560: ** multi-file transaction that included the database associated with
! 1561: ** the IO error (i.e. a database ATTACHed to the same handle at some
! 1562: ** point in time).
! 1563: */
! 1564: if( rc!=SQLITE_OK ){
! 1565: async.ioError = rc;
! 1566: }
! 1567:
! 1568: if( async.ioError && !async.pQueueFirst ){
! 1569: async_mutex_enter(ASYNC_MUTEX_LOCK);
! 1570: if( 0==async.pLock ){
! 1571: async.ioError = SQLITE_OK;
! 1572: }
! 1573: async_mutex_leave(ASYNC_MUTEX_LOCK);
! 1574: }
! 1575:
! 1576: /* Drop the queue mutex before continuing to the next write operation
! 1577: ** in order to give other threads a chance to work with the write queue.
! 1578: */
! 1579: if( !async.pQueueFirst || !async.ioError ){
! 1580: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1581: holdingMutex = 0;
! 1582: if( async.ioDelay>0 ){
! 1583: pVfs->xSleep(pVfs, async.ioDelay*1000);
! 1584: }else{
! 1585: async_sched_yield();
! 1586: }
! 1587: }
! 1588: }
! 1589:
! 1590: async_mutex_leave(ASYNC_MUTEX_WRITER);
! 1591: return;
! 1592: }
! 1593:
! 1594: /*
! 1595: ** Install the asynchronous VFS.
! 1596: */
! 1597: int sqlite3async_initialize(const char *zParent, int isDefault){
! 1598: int rc = SQLITE_OK;
! 1599: if( async_vfs.pAppData==0 ){
! 1600: sqlite3_vfs *pParent = sqlite3_vfs_find(zParent);
! 1601: if( !pParent || async_os_initialize() ){
! 1602: rc = SQLITE_ERROR;
! 1603: }else if( SQLITE_OK!=(rc = sqlite3_vfs_register(&async_vfs, isDefault)) ){
! 1604: async_os_shutdown();
! 1605: }else{
! 1606: async_vfs.pAppData = (void *)pParent;
! 1607: async_vfs.mxPathname = ((sqlite3_vfs *)async_vfs.pAppData)->mxPathname;
! 1608: }
! 1609: }
! 1610: return rc;
! 1611: }
! 1612:
! 1613: /*
! 1614: ** Uninstall the asynchronous VFS.
! 1615: */
! 1616: void sqlite3async_shutdown(void){
! 1617: if( async_vfs.pAppData ){
! 1618: async_os_shutdown();
! 1619: sqlite3_vfs_unregister((sqlite3_vfs *)&async_vfs);
! 1620: async_vfs.pAppData = 0;
! 1621: }
! 1622: }
! 1623:
! 1624: /*
! 1625: ** Process events on the write-queue.
! 1626: */
! 1627: void sqlite3async_run(void){
! 1628: asyncWriterThread();
! 1629: }
! 1630:
! 1631: /*
! 1632: ** Control/configure the asynchronous IO system.
! 1633: */
! 1634: int sqlite3async_control(int op, ...){
! 1635: va_list ap;
! 1636: va_start(ap, op);
! 1637: switch( op ){
! 1638: case SQLITEASYNC_HALT: {
! 1639: int eWhen = va_arg(ap, int);
! 1640: if( eWhen!=SQLITEASYNC_HALT_NEVER
! 1641: && eWhen!=SQLITEASYNC_HALT_NOW
! 1642: && eWhen!=SQLITEASYNC_HALT_IDLE
! 1643: ){
! 1644: return SQLITE_MISUSE;
! 1645: }
! 1646: async.eHalt = eWhen;
! 1647: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1648: async_cond_signal(ASYNC_COND_QUEUE);
! 1649: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1650: break;
! 1651: }
! 1652:
! 1653: case SQLITEASYNC_DELAY: {
! 1654: int iDelay = va_arg(ap, int);
! 1655: if( iDelay<0 ){
! 1656: return SQLITE_MISUSE;
! 1657: }
! 1658: async.ioDelay = iDelay;
! 1659: break;
! 1660: }
! 1661:
! 1662: case SQLITEASYNC_LOCKFILES: {
! 1663: int bLock = va_arg(ap, int);
! 1664: async_mutex_enter(ASYNC_MUTEX_QUEUE);
! 1665: if( async.nFile || async.pQueueFirst ){
! 1666: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1667: return SQLITE_MISUSE;
! 1668: }
! 1669: async.bLockFiles = bLock;
! 1670: async_mutex_leave(ASYNC_MUTEX_QUEUE);
! 1671: break;
! 1672: }
! 1673:
! 1674: case SQLITEASYNC_GET_HALT: {
! 1675: int *peWhen = va_arg(ap, int *);
! 1676: *peWhen = async.eHalt;
! 1677: break;
! 1678: }
! 1679: case SQLITEASYNC_GET_DELAY: {
! 1680: int *piDelay = va_arg(ap, int *);
! 1681: *piDelay = async.ioDelay;
! 1682: break;
! 1683: }
! 1684: case SQLITEASYNC_GET_LOCKFILES: {
! 1685: int *piDelay = va_arg(ap, int *);
! 1686: *piDelay = async.bLockFiles;
! 1687: break;
! 1688: }
! 1689:
! 1690: default:
! 1691: return SQLITE_ERROR;
! 1692: }
! 1693: return SQLITE_OK;
! 1694: }
! 1695:
! 1696: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO) */
! 1697:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sqlite3async.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / ext / async