/[zanavi_public1]/navit/navit/maptool/sqlite3async.c
ZANavi

Contents of /navit/navit/maptool/sqlite3async.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Mon Feb 4 17:41:59 2013 UTC (11 years, 1 month ago) by zoff99
File MIME type: text/plain
File size: 54630 byte(s)
new map version, lots of fixes and experimental new features
1 zoff99 31 /*
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_NOTFOUND;
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     ** Otherwise, allocate enough space to make a copy of the file name (along
1049     ** with the second nul-terminator byte required by xOpen).
1050     */
1051     if( zName ){
1052     nName = (int)strlen(zName);
1053     }
1054    
1055     nByte = (
1056     sizeof(AsyncFileData) + /* AsyncFileData structure */
1057     2 * pVfs->szOsFile + /* AsyncFileData.pBaseRead and pBaseWrite */
1058     nName + 2 /* AsyncFileData.zName */
1059     );
1060     z = sqlite3_malloc(nByte);
1061     if( !z ){
1062     return SQLITE_NOMEM;
1063     }
1064     memset(z, 0, nByte);
1065     pData = (AsyncFileData*)z;
1066     z += sizeof(pData[0]);
1067     pData->pBaseRead = (sqlite3_file*)z;
1068     z += pVfs->szOsFile;
1069     pData->pBaseWrite = (sqlite3_file*)z;
1070     pData->closeOp.pFileData = pData;
1071     pData->closeOp.op = ASYNC_CLOSE;
1072    
1073     if( zName ){
1074     z += pVfs->szOsFile;
1075     pData->zName = z;
1076     pData->nName = nName;
1077     memcpy(pData->zName, zName, nName);
1078     }
1079    
1080     if( !isAsyncOpen ){
1081     int flagsout;
1082     rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseRead, flags, &flagsout);
1083     if( rc==SQLITE_OK
1084     && (flagsout&SQLITE_OPEN_READWRITE)
1085     && (flags&SQLITE_OPEN_EXCLUSIVE)==0
1086     ){
1087     rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseWrite, flags, 0);
1088     }
1089     if( pOutFlags ){
1090     *pOutFlags = flagsout;
1091     }
1092     }
1093    
1094     async_mutex_enter(ASYNC_MUTEX_LOCK);
1095    
1096     if( zName && rc==SQLITE_OK ){
1097     pLock = findLock(pData->zName, pData->nName);
1098     if( !pLock ){
1099     int nByte = pVfs->szOsFile + sizeof(AsyncLock) + pData->nName + 1;
1100     pLock = (AsyncLock *)sqlite3_malloc(nByte);
1101     if( pLock ){
1102     memset(pLock, 0, nByte);
1103     if( async.bLockFiles && (flags&SQLITE_OPEN_MAIN_DB) ){
1104     pLock->pFile = (sqlite3_file *)&pLock[1];
1105     rc = pVfs->xOpen(pVfs, pData->zName, pLock->pFile, flags, 0);
1106     if( rc!=SQLITE_OK ){
1107     sqlite3_free(pLock);
1108     pLock = 0;
1109     }
1110     }
1111     if( pLock ){
1112     pLock->nFile = pData->nName;
1113     pLock->zFile = &((char *)(&pLock[1]))[pVfs->szOsFile];
1114     memcpy(pLock->zFile, pData->zName, pLock->nFile);
1115     pLock->pNext = async.pLock;
1116     async.pLock = pLock;
1117     }
1118     }else{
1119     rc = SQLITE_NOMEM;
1120     }
1121     }
1122     }
1123    
1124     if( rc==SQLITE_OK ){
1125     p->pMethod = &async_methods;
1126     p->pData = pData;
1127    
1128     /* Link AsyncFileData.lock into the linked list of
1129     ** AsyncFileLock structures for this file.
1130     */
1131     if( zName ){
1132     pData->lock.pNext = pLock->pList;
1133     pLock->pList = &pData->lock;
1134     pData->zName = pLock->zFile;
1135     }
1136     }else{
1137     if( pData->pBaseRead->pMethods ){
1138     pData->pBaseRead->pMethods->xClose(pData->pBaseRead);
1139     }
1140     if( pData->pBaseWrite->pMethods ){
1141     pData->pBaseWrite->pMethods->xClose(pData->pBaseWrite);
1142     }
1143     sqlite3_free(pData);
1144     }
1145    
1146     async_mutex_leave(ASYNC_MUTEX_LOCK);
1147    
1148     if( rc==SQLITE_OK ){
1149     pData->pLock = pLock;
1150     }
1151    
1152     if( rc==SQLITE_OK && isAsyncOpen ){
1153     rc = addNewAsyncWrite(pData, ASYNC_OPENEXCLUSIVE, (sqlite3_int64)flags,0,0);
1154     if( rc==SQLITE_OK ){
1155     if( pOutFlags ) *pOutFlags = flags;
1156     }else{
1157     async_mutex_enter(ASYNC_MUTEX_LOCK);
1158     unlinkAsyncFile(pData);
1159     async_mutex_leave(ASYNC_MUTEX_LOCK);
1160     sqlite3_free(pData);
1161     }
1162     }
1163     if( rc!=SQLITE_OK ){
1164     p->pMethod = 0;
1165     }else{
1166     incrOpenFileCount();
1167     }
1168    
1169     return rc;
1170     }
1171    
1172     /*
1173     ** Implementation of sqlite3OsDelete. Add an entry to the end of the
1174     ** write-op queue to perform the delete.
1175     */
1176     static int asyncDelete(sqlite3_vfs *pAsyncVfs, const char *z, int syncDir){
1177     UNUSED_PARAMETER(pAsyncVfs);
1178     return addNewAsyncWrite(0, ASYNC_DELETE, syncDir, (int)strlen(z)+1, z);
1179     }
1180    
1181     /*
1182     ** Implementation of sqlite3OsAccess. This method holds the mutex from
1183     ** start to finish.
1184     */
1185     static int asyncAccess(
1186     sqlite3_vfs *pAsyncVfs,
1187     const char *zName,
1188     int flags,
1189     int *pResOut
1190     ){
1191     int rc;
1192     int ret;
1193     AsyncWrite *p;
1194     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1195    
1196     assert(flags==SQLITE_ACCESS_READWRITE
1197     || flags==SQLITE_ACCESS_READ
1198     || flags==SQLITE_ACCESS_EXISTS
1199     );
1200    
1201     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1202     rc = pVfs->xAccess(pVfs, zName, flags, &ret);
1203     if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
1204     for(p=async.pQueueFirst; p; p = p->pNext){
1205     if( p->op==ASYNC_DELETE && 0==strcmp(p->zBuf, zName) ){
1206     ret = 0;
1207     }else if( p->op==ASYNC_OPENEXCLUSIVE
1208     && p->pFileData->zName
1209     && 0==strcmp(p->pFileData->zName, zName)
1210     ){
1211     ret = 1;
1212     }
1213     }
1214     }
1215     ASYNC_TRACE(("ACCESS(%s): %s = %d\n",
1216     flags==SQLITE_ACCESS_READWRITE?"read-write":
1217     flags==SQLITE_ACCESS_READ?"read":"exists"
1218     , zName, ret)
1219     );
1220     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1221     *pResOut = ret;
1222     return rc;
1223     }
1224    
1225     /*
1226     ** Fill in zPathOut with the full path to the file identified by zPath.
1227     */
1228     static int asyncFullPathname(
1229     sqlite3_vfs *pAsyncVfs,
1230     const char *zPath,
1231     int nPathOut,
1232     char *zPathOut
1233     ){
1234     int rc;
1235     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1236     rc = pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
1237    
1238     /* Because of the way intra-process file locking works, this backend
1239     ** needs to return a canonical path. The following block assumes the
1240     ** file-system uses unix style paths.
1241     */
1242     if( rc==SQLITE_OK ){
1243     int i, j;
1244     char *z = zPathOut;
1245     int n = (int)strlen(z);
1246     while( n>1 && z[n-1]=='/' ){ n--; }
1247     for(i=j=0; i<n; i++){
1248     if( z[i]=='/' ){
1249     if( z[i+1]=='/' ) continue;
1250     if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
1251     i += 1;
1252     continue;
1253     }
1254     if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
1255     while( j>0 && z[j-1]!='/' ){ j--; }
1256     if( j>0 ){ j--; }
1257     i += 2;
1258     continue;
1259     }
1260     }
1261     z[j++] = z[i];
1262     }
1263     z[j] = 0;
1264     }
1265    
1266     return rc;
1267     }
1268     static void *asyncDlOpen(sqlite3_vfs *pAsyncVfs, const char *zPath){
1269     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1270     return pVfs->xDlOpen(pVfs, zPath);
1271     }
1272     static void asyncDlError(sqlite3_vfs *pAsyncVfs, int nByte, char *zErrMsg){
1273     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1274     pVfs->xDlError(pVfs, nByte, zErrMsg);
1275     }
1276     static void (*asyncDlSym(
1277     sqlite3_vfs *pAsyncVfs,
1278     void *pHandle,
1279     const char *zSymbol
1280     ))(void){
1281     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1282     return pVfs->xDlSym(pVfs, pHandle, zSymbol);
1283     }
1284     static void asyncDlClose(sqlite3_vfs *pAsyncVfs, void *pHandle){
1285     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1286     pVfs->xDlClose(pVfs, pHandle);
1287     }
1288     static int asyncRandomness(sqlite3_vfs *pAsyncVfs, int nByte, char *zBufOut){
1289     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1290     return pVfs->xRandomness(pVfs, nByte, zBufOut);
1291     }
1292     static int asyncSleep(sqlite3_vfs *pAsyncVfs, int nMicro){
1293     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1294     return pVfs->xSleep(pVfs, nMicro);
1295     }
1296     static int asyncCurrentTime(sqlite3_vfs *pAsyncVfs, double *pTimeOut){
1297     sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
1298     return pVfs->xCurrentTime(pVfs, pTimeOut);
1299     }
1300    
1301     static sqlite3_vfs async_vfs = {
1302     1, /* iVersion */
1303     sizeof(AsyncFile), /* szOsFile */
1304     0, /* mxPathname */
1305     0, /* pNext */
1306     SQLITEASYNC_VFSNAME, /* zName */
1307     0, /* pAppData */
1308     asyncOpen, /* xOpen */
1309     asyncDelete, /* xDelete */
1310     asyncAccess, /* xAccess */
1311     asyncFullPathname, /* xFullPathname */
1312     asyncDlOpen, /* xDlOpen */
1313     asyncDlError, /* xDlError */
1314     asyncDlSym, /* xDlSym */
1315     asyncDlClose, /* xDlClose */
1316     asyncRandomness, /* xDlError */
1317     asyncSleep, /* xDlSym */
1318     asyncCurrentTime /* xDlClose */
1319     };
1320    
1321     /*
1322     ** This procedure runs in a separate thread, reading messages off of the
1323     ** write queue and processing them one by one.
1324     **
1325     ** If async.writerHaltNow is true, then this procedure exits
1326     ** after processing a single message.
1327     **
1328     ** If async.writerHaltWhenIdle is true, then this procedure exits when
1329     ** the write queue is empty.
1330     **
1331     ** If both of the above variables are false, this procedure runs
1332     ** indefinately, waiting for operations to be added to the write queue
1333     ** and processing them in the order in which they arrive.
1334     **
1335     ** An artifical delay of async.ioDelay milliseconds is inserted before
1336     ** each write operation in order to simulate the effect of a slow disk.
1337     **
1338     ** Only one instance of this procedure may be running at a time.
1339     */
1340     static void asyncWriterThread(void){
1341     sqlite3_vfs *pVfs = (sqlite3_vfs *)(async_vfs.pAppData);
1342     AsyncWrite *p = 0;
1343     int rc = SQLITE_OK;
1344     int holdingMutex = 0;
1345    
1346     async_mutex_enter(ASYNC_MUTEX_WRITER);
1347    
1348     while( async.eHalt!=SQLITEASYNC_HALT_NOW ){
1349     int doNotFree = 0;
1350     sqlite3_file *pBase = 0;
1351    
1352     if( !holdingMutex ){
1353     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1354     }
1355     while( (p = async.pQueueFirst)==0 ){
1356     if( async.eHalt!=SQLITEASYNC_HALT_NEVER ){
1357     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1358     break;
1359     }else{
1360     ASYNC_TRACE(("IDLE\n"));
1361     async_cond_wait(ASYNC_COND_QUEUE, ASYNC_MUTEX_QUEUE);
1362     ASYNC_TRACE(("WAKEUP\n"));
1363     }
1364     }
1365     if( p==0 ) break;
1366     holdingMutex = 1;
1367    
1368     /* Right now this thread is holding the mutex on the write-op queue.
1369     ** Variable 'p' points to the first entry in the write-op queue. In
1370     ** the general case, we hold on to the mutex for the entire body of
1371     ** the loop.
1372     **
1373     ** However in the cases enumerated below, we relinquish the mutex,
1374     ** perform the IO, and then re-request the mutex before removing 'p' from
1375     ** the head of the write-op queue. The idea is to increase concurrency with
1376     ** sqlite threads.
1377     **
1378     ** * An ASYNC_CLOSE operation.
1379     ** * An ASYNC_OPENEXCLUSIVE operation. For this one, we relinquish
1380     ** the mutex, call the underlying xOpenExclusive() function, then
1381     ** re-aquire the mutex before seting the AsyncFile.pBaseRead
1382     ** variable.
1383     ** * ASYNC_SYNC and ASYNC_WRITE operations, if
1384     ** SQLITE_ASYNC_TWO_FILEHANDLES was set at compile time and two
1385     ** file-handles are open for the particular file being "synced".
1386     */
1387     if( async.ioError!=SQLITE_OK && p->op!=ASYNC_CLOSE ){
1388     p->op = ASYNC_NOOP;
1389     }
1390     if( p->pFileData ){
1391     pBase = p->pFileData->pBaseWrite;
1392     if(
1393     p->op==ASYNC_CLOSE ||
1394     p->op==ASYNC_OPENEXCLUSIVE ||
1395     (pBase->pMethods && (p->op==ASYNC_SYNC || p->op==ASYNC_WRITE) )
1396     ){
1397     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1398     holdingMutex = 0;
1399     }
1400     if( !pBase->pMethods ){
1401     pBase = p->pFileData->pBaseRead;
1402     }
1403     }
1404    
1405     switch( p->op ){
1406     case ASYNC_NOOP:
1407     break;
1408    
1409     case ASYNC_WRITE:
1410     assert( pBase );
1411     ASYNC_TRACE(("WRITE %s %d bytes at %d\n",
1412     p->pFileData->zName, p->nByte, p->iOffset));
1413     rc = pBase->pMethods->xWrite(pBase, (void *)(p->zBuf), p->nByte, p->iOffset);
1414     break;
1415    
1416     case ASYNC_SYNC:
1417     assert( pBase );
1418     ASYNC_TRACE(("SYNC %s\n", p->pFileData->zName));
1419     rc = pBase->pMethods->xSync(pBase, p->nByte);
1420     break;
1421    
1422     case ASYNC_TRUNCATE:
1423     assert( pBase );
1424     ASYNC_TRACE(("TRUNCATE %s to %d bytes\n",
1425     p->pFileData->zName, p->iOffset));
1426     rc = pBase->pMethods->xTruncate(pBase, p->iOffset);
1427     break;
1428    
1429     case ASYNC_CLOSE: {
1430     AsyncFileData *pData = p->pFileData;
1431     ASYNC_TRACE(("CLOSE %s\n", p->pFileData->zName));
1432     if( pData->pBaseWrite->pMethods ){
1433     pData->pBaseWrite->pMethods->xClose(pData->pBaseWrite);
1434     }
1435     if( pData->pBaseRead->pMethods ){
1436     pData->pBaseRead->pMethods->xClose(pData->pBaseRead);
1437     }
1438    
1439     /* Unlink AsyncFileData.lock from the linked list of AsyncFileLock
1440     ** structures for this file. Obtain the async.lockMutex mutex
1441     ** before doing so.
1442     */
1443     async_mutex_enter(ASYNC_MUTEX_LOCK);
1444     rc = unlinkAsyncFile(pData);
1445     async_mutex_leave(ASYNC_MUTEX_LOCK);
1446    
1447     if( !holdingMutex ){
1448     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1449     holdingMutex = 1;
1450     }
1451     assert_mutex_is_held(ASYNC_MUTEX_QUEUE);
1452     async.pQueueFirst = p->pNext;
1453     sqlite3_free(pData);
1454     doNotFree = 1;
1455     break;
1456     }
1457    
1458     case ASYNC_UNLOCK: {
1459     AsyncWrite *pIter;
1460     AsyncFileData *pData = p->pFileData;
1461     int eLock = p->nByte;
1462    
1463     /* When a file is locked by SQLite using the async backend, it is
1464     ** locked within the 'real' file-system synchronously. When it is
1465     ** unlocked, an ASYNC_UNLOCK event is added to the write-queue to
1466     ** unlock the file asynchronously. The design of the async backend
1467     ** requires that the 'real' file-system file be locked from the
1468     ** time that SQLite first locks it (and probably reads from it)
1469     ** until all asynchronous write events that were scheduled before
1470     ** SQLite unlocked the file have been processed.
1471     **
1472     ** This is more complex if SQLite locks and unlocks the file multiple
1473     ** times in quick succession. For example, if SQLite does:
1474     **
1475     ** lock, write, unlock, lock, write, unlock
1476     **
1477     ** Each "lock" operation locks the file immediately. Each "write"
1478     ** and "unlock" operation adds an event to the event queue. If the
1479     ** second "lock" operation is performed before the first "unlock"
1480     ** operation has been processed asynchronously, then the first
1481     ** "unlock" cannot be safely processed as is, since this would mean
1482     ** the file was unlocked when the second "write" operation is
1483     ** processed. To work around this, when processing an ASYNC_UNLOCK
1484     ** operation, SQLite:
1485     **
1486     ** 1) Unlocks the file to the minimum of the argument passed to
1487     ** the xUnlock() call and the current lock from SQLite's point
1488     ** of view, and
1489     **
1490     ** 2) Only unlocks the file at all if this event is the last
1491     ** ASYNC_UNLOCK event on this file in the write-queue.
1492     */
1493     assert( holdingMutex==1 );
1494     assert( async.pQueueFirst==p );
1495     for(pIter=async.pQueueFirst->pNext; pIter; pIter=pIter->pNext){
1496     if( pIter->pFileData==pData && pIter->op==ASYNC_UNLOCK ) break;
1497     }
1498     if( !pIter ){
1499     async_mutex_enter(ASYNC_MUTEX_LOCK);
1500     pData->lock.eAsyncLock = MIN(
1501     pData->lock.eAsyncLock, MAX(pData->lock.eLock, eLock)
1502     );
1503     assert(pData->lock.eAsyncLock>=pData->lock.eLock);
1504     rc = getFileLock(pData->pLock);
1505     async_mutex_leave(ASYNC_MUTEX_LOCK);
1506     }
1507     break;
1508     }
1509    
1510     case ASYNC_DELETE:
1511     ASYNC_TRACE(("DELETE %s\n", p->zBuf));
1512     rc = pVfs->xDelete(pVfs, p->zBuf, (int)p->iOffset);
1513     break;
1514    
1515     case ASYNC_OPENEXCLUSIVE: {
1516     int flags = (int)p->iOffset;
1517     AsyncFileData *pData = p->pFileData;
1518     ASYNC_TRACE(("OPEN %s flags=%d\n", p->zBuf, (int)p->iOffset));
1519     assert(pData->pBaseRead->pMethods==0 && pData->pBaseWrite->pMethods==0);
1520     rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseRead, flags, 0);
1521     assert( holdingMutex==0 );
1522     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1523     holdingMutex = 1;
1524     break;
1525     }
1526    
1527     default: assert(!"Illegal value for AsyncWrite.op");
1528     }
1529    
1530     /* If we didn't hang on to the mutex during the IO op, obtain it now
1531     ** so that the AsyncWrite structure can be safely removed from the
1532     ** global write-op queue.
1533     */
1534     if( !holdingMutex ){
1535     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1536     holdingMutex = 1;
1537     }
1538     /* ASYNC_TRACE(("UNLINK %p\n", p)); */
1539     if( p==async.pQueueLast ){
1540     async.pQueueLast = 0;
1541     }
1542     if( !doNotFree ){
1543     assert_mutex_is_held(ASYNC_MUTEX_QUEUE);
1544     async.pQueueFirst = p->pNext;
1545     sqlite3_free(p);
1546     }
1547     assert( holdingMutex );
1548    
1549     /* An IO error has occurred. We cannot report the error back to the
1550     ** connection that requested the I/O since the error happened
1551     ** asynchronously. The connection has already moved on. There
1552     ** really is nobody to report the error to.
1553     **
1554     ** The file for which the error occurred may have been a database or
1555     ** journal file. Regardless, none of the currently queued operations
1556     ** associated with the same database should now be performed. Nor should
1557     ** any subsequently requested IO on either a database or journal file
1558     ** handle for the same database be accepted until the main database
1559     ** file handle has been closed and reopened.
1560     **
1561     ** Furthermore, no further IO should be queued or performed on any file
1562     ** handle associated with a database that may have been part of a
1563     ** multi-file transaction that included the database associated with
1564     ** the IO error (i.e. a database ATTACHed to the same handle at some
1565     ** point in time).
1566     */
1567     if( rc!=SQLITE_OK ){
1568     async.ioError = rc;
1569     }
1570    
1571     if( async.ioError && !async.pQueueFirst ){
1572     async_mutex_enter(ASYNC_MUTEX_LOCK);
1573     if( 0==async.pLock ){
1574     async.ioError = SQLITE_OK;
1575     }
1576     async_mutex_leave(ASYNC_MUTEX_LOCK);
1577     }
1578    
1579     /* Drop the queue mutex before continuing to the next write operation
1580     ** in order to give other threads a chance to work with the write queue.
1581     */
1582     if( !async.pQueueFirst || !async.ioError ){
1583     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1584     holdingMutex = 0;
1585     if( async.ioDelay>0 ){
1586     pVfs->xSleep(pVfs, async.ioDelay*1000);
1587     }else{
1588     async_sched_yield();
1589     }
1590     }
1591     }
1592    
1593     async_mutex_leave(ASYNC_MUTEX_WRITER);
1594     return;
1595     }
1596    
1597     /*
1598     ** Install the asynchronous VFS.
1599     */
1600     int sqlite3async_initialize(const char *zParent, int isDefault){
1601     int rc = SQLITE_OK;
1602     if( async_vfs.pAppData==0 ){
1603     sqlite3_vfs *pParent = sqlite3_vfs_find(zParent);
1604     if( !pParent || async_os_initialize() ){
1605     rc = SQLITE_ERROR;
1606     }else if( SQLITE_OK!=(rc = sqlite3_vfs_register(&async_vfs, isDefault)) ){
1607     async_os_shutdown();
1608     }else{
1609     async_vfs.pAppData = (void *)pParent;
1610     async_vfs.mxPathname = ((sqlite3_vfs *)async_vfs.pAppData)->mxPathname;
1611     }
1612     }
1613     return rc;
1614     }
1615    
1616     /*
1617     ** Uninstall the asynchronous VFS.
1618     */
1619     void sqlite3async_shutdown(void){
1620     if( async_vfs.pAppData ){
1621     async_os_shutdown();
1622     sqlite3_vfs_unregister((sqlite3_vfs *)&async_vfs);
1623     async_vfs.pAppData = 0;
1624     }
1625     }
1626    
1627     /*
1628     ** Process events on the write-queue.
1629     */
1630     void sqlite3async_run(void){
1631     asyncWriterThread();
1632     }
1633    
1634     /*
1635     ** Control/configure the asynchronous IO system.
1636     */
1637     int sqlite3async_control(int op, ...){
1638     va_list ap;
1639     va_start(ap, op);
1640     switch( op ){
1641     case SQLITEASYNC_HALT: {
1642     int eWhen = va_arg(ap, int);
1643     if( eWhen!=SQLITEASYNC_HALT_NEVER
1644     && eWhen!=SQLITEASYNC_HALT_NOW
1645     && eWhen!=SQLITEASYNC_HALT_IDLE
1646     ){
1647     return SQLITE_MISUSE;
1648     }
1649     async.eHalt = eWhen;
1650     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1651     async_cond_signal(ASYNC_COND_QUEUE);
1652     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1653     break;
1654     }
1655    
1656     case SQLITEASYNC_DELAY: {
1657     int iDelay = va_arg(ap, int);
1658     if( iDelay<0 ){
1659     return SQLITE_MISUSE;
1660     }
1661     async.ioDelay = iDelay;
1662     break;
1663     }
1664    
1665     case SQLITEASYNC_LOCKFILES: {
1666     int bLock = va_arg(ap, int);
1667     async_mutex_enter(ASYNC_MUTEX_QUEUE);
1668     if( async.nFile || async.pQueueFirst ){
1669     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1670     return SQLITE_MISUSE;
1671     }
1672     async.bLockFiles = bLock;
1673     async_mutex_leave(ASYNC_MUTEX_QUEUE);
1674     break;
1675     }
1676    
1677     case SQLITEASYNC_GET_HALT: {
1678     int *peWhen = va_arg(ap, int *);
1679     *peWhen = async.eHalt;
1680     break;
1681     }
1682     case SQLITEASYNC_GET_DELAY: {
1683     int *piDelay = va_arg(ap, int *);
1684     *piDelay = async.ioDelay;
1685     break;
1686     }
1687     case SQLITEASYNC_GET_LOCKFILES: {
1688     int *piDelay = va_arg(ap, int *);
1689     *piDelay = async.bLockFiles;
1690     break;
1691     }
1692    
1693     default:
1694     return SQLITE_ERROR;
1695     }
1696     return SQLITE_OK;
1697     }
1698    
1699     #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO) */
1700    
1701    

   
Visit the ZANavi Wiki