/[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 - (show annotations) (download)
Mon Feb 4 17:41:59 2013 UTC (7 years, 6 months ago) by zoff99
File MIME type: text/plain
File size: 54630 byte(s)
new map version, lots of fixes and experimental new features
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_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