/*

** 2005 December 14

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** May you do good and not evil.

** May you find forgiveness for yourself and forgive others.

** May you share freely, never taking more than you give.

**

*************************************************************************

**

** $Id: sqlite3async.c,v 1.7 2009/07/18 11:52:04 danielk1977 Exp $

**

** This file contains the implementation of an asynchronous IO backend

** for SQLite.

*/

#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO)

#include "sqlite3async.h"

#include "sqlite3.h"

#include <stdarg.h>

#include <string.h>

#include <assert.h>

/* Useful macros used in several places */

#define MIN(x,y) ((x)<(y)?(x):(y))

#define MAX(x,y) ((x)>(y)?(x):(y))

#ifndef SQLITE_AMALGAMATION

/* Macro to mark parameters as unused and silence compiler warnings. */

#define UNUSED_PARAMETER(x) (void)(x)

#endif

/* Forward references */

typedef struct AsyncWrite AsyncWrite;

typedef struct AsyncFile AsyncFile;

typedef struct AsyncFileData AsyncFileData;

typedef struct AsyncFileLock AsyncFileLock;

typedef struct AsyncLock AsyncLock;

/* Enable for debugging */

#ifndef NDEBUG

#include <stdio.h>

static int sqlite3async_trace = 0;

# define ASYNC_TRACE(X) if( sqlite3async_trace ) asyncTrace X

static void asyncTrace(const char *zFormat, ...){

char *z;

va_list ap;

va_start(ap, zFormat);

z = sqlite3_vmprintf(zFormat, ap);

va_end(ap);

fprintf(stderr, "[%d] %s", 0 /* (int)pthread_self() */, z);

sqlite3_free(z);

}

#else

# define ASYNC_TRACE(X)

#endif

/*

** THREAD SAFETY NOTES

**

** Basic rules:

**

** * Both read and write access to the global write-op queue must be

** protected by the async.queueMutex. As are the async.ioError and

** async.nFile variables.

**

** * The async.pLock list and all AsyncLock and AsyncFileLock

** structures must be protected by the async.lockMutex mutex.

**

** * The file handles from the underlying system are not assumed to

** be thread safe.

**

** * See the last two paragraphs under "The Writer Thread" for

** an assumption to do with file-handle synchronization by the Os.

**

** Deadlock prevention:

**

** There are three mutex used by the system: the "writer" mutex,

** the "queue" mutex and the "lock" mutex. Rules are:

**

** * It is illegal to block on the writer mutex when any other mutex

** are held, and

**

** * It is illegal to block on the queue mutex when the lock mutex

** is held.

**

** i.e. mutex's must be grabbed in the order "writer", "queue", "lock".

**

** File system operations (invoked by SQLite thread):

**

** xOpen

** xDelete

** xFileExists

**

** File handle operations (invoked by SQLite thread):

**

** asyncWrite, asyncClose, asyncTruncate, asyncSync

**

** The operations above add an entry to the global write-op list. They

** prepare the entry, acquire the async.queueMutex momentarily while

** list pointers are manipulated to insert the new entry, then release

** the mutex and signal the writer thread to wake up in case it happens

** to be asleep.

**

**

** asyncRead, asyncFileSize.

**

** Read operations. Both of these read from both the underlying file

** first then adjust their result based on pending writes in the

** write-op queue. So async.queueMutex is held for the duration

** of these operations to prevent other threads from changing the

** queue in mid operation.

**

**

** asyncLock, asyncUnlock, asyncCheckReservedLock

**

** These primitives implement in-process locking using a hash table

** on the file name. Files are locked correctly for connections coming

** from the same process. But other processes cannot see these locks

** and will therefore not honor them.

**

**

** The writer thread:

**

** The async.writerMutex is used to make sure only there is only

** a single writer thread running at a time.

**

** Inside the writer thread is a loop that works like this:

**

** WHILE (write-op list is not empty)

** Do IO operation at head of write-op list

** Remove entry from head of write-op list

** END WHILE

**

** The async.queueMutex is always held during the <write-op list is

** not empty> test, and when the entry is removed from the head

** of the write-op list. Sometimes it is held for the interim

** period (while the IO is performed), and sometimes it is

** relinquished. It is relinquished if (a) the IO op is an

** ASYNC_CLOSE or (b) when the file handle was opened, two of

** the underlying systems handles were opened on the same

** file-system entry.

**

** If condition (b) above is true, then one file-handle

** (AsyncFile.pBaseRead) is used exclusively by sqlite threads to read the

** file, the other (AsyncFile.pBaseWrite) by sqlite3_async_flush()

** threads to perform write() operations. This means that read

** operations are not blocked by asynchronous writes (although

** asynchronous writes may still be blocked by reads).

**

** This assumes that the OS keeps two handles open on the same file

** properly in sync. That is, any read operation that starts after a

** write operation on the same file system entry has completed returns

** data consistent with the write. We also assume that if one thread

** reads a file while another is writing it all bytes other than the

** ones actually being written contain valid data.

**

** If the above assumptions are not true, set the preprocessor symbol

** SQLITE_ASYNC_TWO_FILEHANDLES to 0.

*/

#ifndef NDEBUG

# define TESTONLY( X ) X

#else

# define TESTONLY( X )

#endif

/*

** PORTING FUNCTIONS

**

** There are two definitions of the following functions. One for pthreads

** compatible systems and one for Win32. These functions isolate the OS

** specific code required by each platform.

**

** The system uses three mutexes and a single condition variable. To

** block on a mutex, async_mutex_enter() is called. The parameter passed

** to async_mutex_enter(), which must be one of ASYNC_MUTEX_LOCK,

** ASYNC_MUTEX_QUEUE or ASYNC_MUTEX_WRITER, identifies which of the three

** mutexes to lock. Similarly, to unlock a mutex, async_mutex_leave() is

** called with a parameter identifying the mutex being unlocked. Mutexes

** are not recursive - it is an error to call async_mutex_enter() to

** lock a mutex that is already locked, or to call async_mutex_leave()

** to unlock a mutex that is not currently locked.

**

** The async_cond_wait() and async_cond_signal() functions are modelled

** on the pthreads functions with similar names. The first parameter to

** both functions is always ASYNC_COND_QUEUE. When async_cond_wait()

** is called the mutex identified by the second parameter must be held.

** The mutex is unlocked, and the calling thread simultaneously begins

** waiting for the condition variable to be signalled by another thread.

** After another thread signals the condition variable, the calling

** thread stops waiting, locks mutex eMutex and returns. The

** async_cond_signal() function is used to signal the condition variable.

** It is assumed that the mutex used by the thread calling async_cond_wait()

** is held by the caller of async_cond_signal() (otherwise there would be

** a race condition).

**

** It is guaranteed that no other thread will call async_cond_wait() when

** there is already a thread waiting on the condition variable.

**

** The async_sched_yield() function is called to suggest to the operating

** system that it would be a good time to shift the current thread off the

** CPU. The system will still work if this function is not implemented

** (it is not currently implemented for win32), but it might be marginally

** more efficient if it is.

*/

static void async_mutex_enter(int eMutex);

static void async_mutex_leave(int eMutex);

static void async_cond_wait(int eCond, int eMutex);

static void async_cond_signal(int eCond);

static void async_sched_yield(void);

/*

** There are also two definitions of the following. async_os_initialize()

** is called when the asynchronous VFS is first installed, and os_shutdown()

** is called when it is uninstalled (from within sqlite3async_shutdown()).

**

** For pthreads builds, both of these functions are no-ops. For win32,

** they provide an opportunity to initialize and finalize the required

** mutex and condition variables.

**

** If async_os_initialize() returns other than zero, then the initialization

** fails and SQLITE_ERROR is returned to the user.

*/

static int async_os_initialize(void);

static void async_os_shutdown(void);

/* Values for use as the 'eMutex' argument of the above functions. The

** integer values assigned to these constants are important for assert()

** statements that verify that mutexes are locked in the correct order.

** Specifically, it is unsafe to try to lock mutex N while holding a lock

** on mutex M if (M<=N).

*/

#define ASYNC_MUTEX_LOCK 0

#define ASYNC_MUTEX_QUEUE 1

#define ASYNC_MUTEX_WRITER 2

/* Values for use as the 'eCond' argument of the above functions. */

#define ASYNC_COND_QUEUE 0

/*************************************************************************

** Start of OS specific code.

*/

#if SQLITE_OS_WIN || defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)

#include <windows.h>

/* The following block contains the win32 specific code. */

#define mutex_held(X) (GetCurrentThreadId()==primitives.aHolder[X])

static struct AsyncPrimitives {

int isInit;

DWORD aHolder[3];

CRITICAL_SECTION aMutex[3];

HANDLE aCond[1];

} primitives = { 0 };

static int async_os_initialize(void){

if( !primitives.isInit ){

primitives.aCond[0] = CreateEvent(NULL, TRUE, FALSE, 0);

if( primitives.aCond[0]==NULL ){

return 1;

}

InitializeCriticalSection(&primitives.aMutex[0]);

InitializeCriticalSection(&primitives.aMutex[1]);

InitializeCriticalSection(&primitives.aMutex[2]);

primitives.isInit = 1;

}

return 0;

}

static void async_os_shutdown(void){

if( primitives.isInit ){

DeleteCriticalSection(&primitives.aMutex[0]);

DeleteCriticalSection(&primitives.aMutex[1]);

DeleteCriticalSection(&primitives.aMutex[2]);

CloseHandle(primitives.aCond[0]);

primitives.isInit = 0;

}

}

/* The following block contains the Win32 specific code. */

static void async_mutex_enter(int eMutex){

assert( eMutex==0 || eMutex==1 || eMutex==2 );

assert( eMutex!=2 || (!mutex_held(0) && !mutex_held(1) && !mutex_held(2)) );

assert( eMutex!=1 || (!mutex_held(0) && !mutex_held(1)) );

assert( eMutex!=0 || (!mutex_held(0)) );

EnterCriticalSection(&primitives.aMutex[eMutex]);

TESTONLY( primitives.aHolder[eMutex] = GetCurrentThreadId(); )

}

static void async_mutex_leave(int eMutex){

assert( eMutex==0 || eMutex==1 || eMutex==2 );

assert( mutex_held(eMutex) );

TESTONLY( primitives.aHolder[eMutex] = 0; )

LeaveCriticalSection(&primitives.aMutex[eMutex]);

}

static void async_cond_wait(int eCond, int eMutex){

ResetEvent(primitives.aCond[eCond]);

async_mutex_leave(eMutex);

WaitForSingleObject(primitives.aCond[eCond], INFINITE);

async_mutex_enter(eMutex);

}

static void async_cond_signal(int eCond){

assert( mutex_held(ASYNC_MUTEX_QUEUE) );

SetEvent(primitives.aCond[eCond]);

}

static void async_sched_yield(void){

Sleep(0);

}

#else

/* The following block contains the pthreads specific code. */

#include <pthread.h>

#include <sched.h>

#define mutex_held(X) pthread_equal(primitives.aHolder[X], pthread_self())

static int async_os_initialize(void) {return 0;}

static void async_os_shutdown(void) {}

static struct AsyncPrimitives {

pthread_mutex_t aMutex[3];

pthread_cond_t aCond[1];

pthread_t aHolder[3];

} primitives = {

{ PTHREAD_MUTEX_INITIALIZER,

PTHREAD_MUTEX_INITIALIZER,

PTHREAD_MUTEX_INITIALIZER

} , {

PTHREAD_COND_INITIALIZER

} , { 0, 0, 0 }

};

static void async_mutex_enter(int eMutex){

assert( eMutex==0 || eMutex==1 || eMutex==2 );

assert( eMutex!=2 || (!mutex_held(0) && !mutex_held(1) && !mutex_held(2)) );

assert( eMutex!=1 || (!mutex_held(0) && !mutex_held(1)) );

assert( eMutex!=0 || (!mutex_held(0)) );

pthread_mutex_lock(&primitives.aMutex[eMutex]);

TESTONLY( primitives.aHolder[eMutex] = pthread_self(); )

}

static void async_mutex_leave(int eMutex){

assert( eMutex==0 || eMutex==1 || eMutex==2 );

assert( mutex_held(eMutex) );

TESTONLY( primitives.aHolder[eMutex] = 0; )

pthread_mutex_unlock(&primitives.aMutex[eMutex]);

}

static void async_cond_wait(int eCond, int eMutex){

assert( eMutex==0 || eMutex==1 || eMutex==2 );

assert( mutex_held(eMutex) );

TESTONLY( primitives.aHolder[eMutex] = 0; )

pthread_cond_wait(&primitives.aCond[eCond], &primitives.aMutex[eMutex]);

TESTONLY( primitives.aHolder[eMutex] = pthread_self(); )

}

static void async_cond_signal(int eCond){

assert( mutex_held(ASYNC_MUTEX_QUEUE) );

pthread_cond_signal(&primitives.aCond[eCond]);

}

static void async_sched_yield(void){

sched_yield();

}

#endif

/*

** End of OS specific code.

*************************************************************************/

#define assert_mutex_is_held(X) assert( mutex_held(X) )

#ifndef SQLITE_ASYNC_TWO_FILEHANDLES

/* #define SQLITE_ASYNC_TWO_FILEHANDLES 0 */

#define SQLITE_ASYNC_TWO_FILEHANDLES 1

#endif

/*

** State information is held in the static variable "async" defined

** as the following structure.

**

** Both async.ioError and async.nFile are protected by async.queueMutex.

*/

static struct TestAsyncStaticData {

AsyncWrite *pQueueFirst; /* Next write operation to be processed */

AsyncWrite *pQueueLast; /* Last write operation on the list */

AsyncLock *pLock; /* Linked list of all AsyncLock structures */

volatile int ioDelay; /* Extra delay between write operations */

volatile int eHalt; /* One of the SQLITEASYNC_HALT_XXX values */

volatile int bLockFiles; /* Current value of "lockfiles" parameter */

int ioError; /* True if an IO error has occurred */

int nFile; /* Number of open files (from sqlite pov) */

} async = { 0,0,0,0,0,1,0,0 };

/* Possible values of AsyncWrite.op */

#define ASYNC_NOOP 0

#define ASYNC_WRITE 1

#define ASYNC_SYNC 2

#define ASYNC_TRUNCATE 3

#define ASYNC_CLOSE 4

#define ASYNC_DELETE 5

#define ASYNC_OPENEXCLUSIVE 6

#define ASYNC_UNLOCK 7

/* Names of opcodes. Used for debugging only.

** Make sure these stay in sync with the macros above!

*/

static const char *azOpcodeName[] = {

"NOOP", "WRITE", "SYNC", "TRUNCATE", "CLOSE", "DELETE", "OPENEX", "UNLOCK"

};

/*

** Entries on the write-op queue are instances of the AsyncWrite

** structure, defined here.

**

** The interpretation of the iOffset and nByte variables varies depending

** on the value of AsyncWrite.op:

**

** ASYNC_NOOP:

** No values used.

**

** ASYNC_WRITE:

** iOffset -> Offset in file to write to.

** nByte -> Number of bytes of data to write (pointed to by zBuf).

**

** ASYNC_SYNC:

** nByte -> flags to pass to sqlite3OsSync().

**

** ASYNC_TRUNCATE:

** iOffset -> Size to truncate file to.

** nByte -> Unused.

**

** ASYNC_CLOSE:

** iOffset -> Unused.

** nByte -> Unused.

**

** ASYNC_DELETE:

** iOffset -> Contains the "syncDir" flag.

** nByte -> Number of bytes of zBuf points to (file name).

**

** ASYNC_OPENEXCLUSIVE:

** iOffset -> Value of "delflag".

** nByte -> Number of bytes of zBuf points to (file name).

**

** ASYNC_UNLOCK:

** nByte -> Argument to sqlite3OsUnlock().

**

**

** For an ASYNC_WRITE operation, zBuf points to the data to write to the file.

** This space is sqlite3_malloc()d along with the AsyncWrite structure in a

** single blob, so is deleted when sqlite3_free() is called on the parent

** structure.

*/

struct AsyncWrite {

AsyncFileData *pFileData; /* File to write data to or sync */

int op; /* One of ASYNC_xxx etc. */

sqlite_int64 iOffset; /* See above */

int nByte; /* See above */

char *zBuf; /* Data to write to file (or NULL if op!=ASYNC_WRITE) */

AsyncWrite *pNext; /* Next write operation (to any file) */

};

/*

** An instance of this structure is created for each distinct open file

** (i.e. if two handles are opened on the one file, only one of these

** structures is allocated) and stored in the async.aLock hash table. The

** keys for async.aLock are the full pathnames of the opened files.

**

** AsyncLock.pList points to the head of a linked list of AsyncFileLock

** structures, one for each handle currently open on the file.

**

** If the opened file is not a main-database (the SQLITE_OPEN_MAIN_DB is

** not passed to the sqlite3OsOpen() call), or if async.bLockFiles is

** false, variables AsyncLock.pFile and AsyncLock.eLock are never used.

** Otherwise, pFile is a file handle opened on the file in question and

** used to obtain the file-system locks required by database connections

** within this process.

**

** See comments above the asyncLock() function for more details on

** the implementation of database locking used by this backend.

*/

struct AsyncLock {

char *zFile;

int nFile;

sqlite3_file *pFile;

int eLock;

AsyncFileLock *pList;

AsyncLock *pNext; /* Next in linked list headed by async.pLock */

};

/*

** An instance of the following structure is allocated along with each

** AsyncFileData structure (see AsyncFileData.lock), but is only used if the

** file was opened with the SQLITE_OPEN_MAIN_DB.

*/

struct AsyncFileLock {

int eLock; /* Internally visible lock state (sqlite pov) */

int eAsyncLock; /* Lock-state with write-queue unlock */

AsyncFileLock *pNext;

};

/*

** The AsyncFile structure is a subclass of sqlite3_file used for

** asynchronous IO.

**

** All of the actual data for the structure is stored in the structure

** pointed to by AsyncFile.pData, which is allocated as part of the

** sqlite3OsOpen() using sqlite3_malloc(). The reason for this is that the

** lifetime of the AsyncFile structure is ended by the caller after OsClose()

** is called, but the data in AsyncFileData may be required by the

** writer thread after that point.

*/

struct AsyncFile {

sqlite3_io_methods *pMethod;

AsyncFileData *pData;

};

struct AsyncFileData {

char *zName; /* Underlying OS filename - used for debugging */

int nName; /* Number of characters in zName */

sqlite3_file *pBaseRead; /* Read handle to the underlying Os file */

sqlite3_file *pBaseWrite; /* Write handle to the underlying Os file */

AsyncFileLock lock; /* Lock state for this handle */

AsyncLock *pLock; /* AsyncLock object for this file system entry */

AsyncWrite closeOp; /* Preallocated close operation */

};

/*

** Add an entry to the end of the global write-op list. pWrite should point

** to an AsyncWrite structure allocated using sqlite3_malloc(). The writer

** thread will call sqlite3_free() to free the structure after the specified

** operation has been completed.

**

** Once an AsyncWrite structure has been added to the list, it becomes the

** property of the writer thread and must not be read or modified by the

** caller.

*/

static void addAsyncWrite(AsyncWrite *pWrite){

/* We must hold the queue mutex in order to modify the queue pointers */

if( pWrite->op!=ASYNC_UNLOCK ){

async_mutex_enter(ASYNC_MUTEX_QUEUE);

}

/* Add the record to the end of the write-op queue */

assert( !pWrite->pNext );

if( async.pQueueLast ){

assert( async.pQueueFirst );

async.pQueueLast->pNext = pWrite;

}else{

async.pQueueFirst = pWrite;

}

async.pQueueLast = pWrite;

ASYNC_TRACE(("PUSH %p (%s %s %d)\n", pWrite, azOpcodeName[pWrite->op],

pWrite->pFileData ? pWrite->pFileData->zName : "-", pWrite->iOffset));

if( pWrite->op==ASYNC_CLOSE ){

async.nFile--;

}

/* The writer thread might have been idle because there was nothing

** on the write-op queue for it to do. So wake it up. */

async_cond_signal(ASYNC_COND_QUEUE);

/* Drop the queue mutex */

if( pWrite->op!=ASYNC_UNLOCK ){

async_mutex_leave(ASYNC_MUTEX_QUEUE);

}

}

/*

** Increment async.nFile in a thread-safe manner.

*/

static void incrOpenFileCount(void){

/* We must hold the queue mutex in order to modify async.nFile */

async_mutex_enter(ASYNC_MUTEX_QUEUE);

if( async.nFile==0 ){

async.ioError = SQLITE_OK;

}

async.nFile++;

async_mutex_leave(ASYNC_MUTEX_QUEUE);

}

/*

** This is a utility function to allocate and populate a new AsyncWrite

** structure and insert it (via addAsyncWrite() ) into the global list.

*/

static int addNewAsyncWrite(

AsyncFileData *pFileData,

int op,

sqlite3_int64 iOffset,

int nByte,

const char *zByte

){

AsyncWrite *p;

if( op!=ASYNC_CLOSE && async.ioError ){

return async.ioError;

}

p = sqlite3_malloc(sizeof(AsyncWrite) + (zByte?nByte:0));

if( !p ){

/* The upper layer does not expect operations like OsWrite() to

** return SQLITE_NOMEM. This is partly because under normal conditions

** SQLite is required to do rollback without calling malloc(). So

** if malloc() fails here, treat it as an I/O error. The above

** layer knows how to handle that.

*/

return SQLITE_IOERR;

}

p->op = op;

p->iOffset = iOffset;

p->nByte = nByte;

p->pFileData = pFileData;

p->pNext = 0;

if( zByte ){

p->zBuf = (char *)&p[1];

memcpy(p->zBuf, zByte, nByte);

}else{

p->zBuf = 0;

}

addAsyncWrite(p);

return SQLITE_OK;

}

/*

** Close the file. This just adds an entry to the write-op list, the file is

** not actually closed.

*/

static int asyncClose(sqlite3_file *pFile){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

/* Unlock the file, if it is locked */

async_mutex_enter(ASYNC_MUTEX_LOCK);

p->lock.eLock = 0;

async_mutex_leave(ASYNC_MUTEX_LOCK);

addAsyncWrite(&p->closeOp);

return SQLITE_OK;

}

/*

** Implementation of sqlite3OsWrite() for asynchronous files. Instead of

** writing to the underlying file, this function adds an entry to the end of

** the global AsyncWrite list. Either SQLITE_OK or SQLITE_NOMEM may be

** returned.

*/

static int asyncWrite(

sqlite3_file *pFile,

const void *pBuf,

int amt,

sqlite3_int64 iOff

){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

return addNewAsyncWrite(p, ASYNC_WRITE, iOff, amt, pBuf);

}

/*

** Read data from the file. First we read from the filesystem, then adjust

** the contents of the buffer based on ASYNC_WRITE operations in the

** write-op queue.

**

** This method holds the mutex from start to finish.

*/

static int asyncRead(

sqlite3_file *pFile,

void *zOut,

int iAmt,

sqlite3_int64 iOffset

){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

int rc = SQLITE_OK;

sqlite3_int64 filesize = 0;

sqlite3_file *pBase = p->pBaseRead;

sqlite3_int64 iAmt64 = (sqlite3_int64)iAmt;

/* Grab the write queue mutex for the duration of the call */

async_mutex_enter(ASYNC_MUTEX_QUEUE);

/* If an I/O error has previously occurred in this virtual file

** system, then all subsequent operations fail.

*/

if( async.ioError!=SQLITE_OK ){

rc = async.ioError;

goto asyncread_out;

}

if( pBase->pMethods ){

sqlite3_int64 nRead;

rc = pBase->pMethods->xFileSize(pBase, &filesize);

if( rc!=SQLITE_OK ){

goto asyncread_out;

}

nRead = MIN(filesize - iOffset, iAmt64);

if( nRead>0 ){

rc = pBase->pMethods->xRead(pBase, zOut, (int)nRead, iOffset);

ASYNC_TRACE(("READ %s %d bytes at %d\n", p->zName, nRead, iOffset));

}

}

if( rc==SQLITE_OK ){

AsyncWrite *pWrite;

char *zName = p->zName;

for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){

if( pWrite->op==ASYNC_WRITE && (

(pWrite->pFileData==p) ||

(zName && pWrite->pFileData->zName==zName)

)){

sqlite3_int64 nCopy;

sqlite3_int64 nByte64 = (sqlite3_int64)pWrite->nByte;

/* Set variable iBeginIn to the offset in buffer pWrite->zBuf[] from

** which data should be copied. Set iBeginOut to the offset within

** the output buffer to which data should be copied. If either of

** these offsets is a negative number, set them to 0.

*/

sqlite3_int64 iBeginOut = (pWrite->iOffset-iOffset);

sqlite3_int64 iBeginIn = -iBeginOut;

if( iBeginIn<0 ) iBeginIn = 0;

if( iBeginOut<0 ) iBeginOut = 0;

filesize = MAX(filesize, pWrite->iOffset+nByte64);

nCopy = MIN(nByte64-iBeginIn, iAmt64-iBeginOut);

if( nCopy>0 ){

memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], (size_t)nCopy);

ASYNC_TRACE(("OVERREAD %d bytes at %d\n", nCopy, iBeginOut+iOffset));

}

}

}

}

asyncread_out:

async_mutex_leave(ASYNC_MUTEX_QUEUE);

if( rc==SQLITE_OK && filesize<(iOffset+iAmt) ){

rc = SQLITE_IOERR_SHORT_READ;

}

return rc;

}

/*

** Truncate the file to nByte bytes in length. This just adds an entry to

** the write-op list, no IO actually takes place.

*/

static int asyncTruncate(sqlite3_file *pFile, sqlite3_int64 nByte){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

return addNewAsyncWrite(p, ASYNC_TRUNCATE, nByte, 0, 0);

}

/*

** Sync the file. This just adds an entry to the write-op list, the

** sync() is done later by sqlite3_async_flush().

*/

static int asyncSync(sqlite3_file *pFile, int flags){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

return addNewAsyncWrite(p, ASYNC_SYNC, 0, flags, 0);

}

/*

** Read the size of the file. First we read the size of the file system

** entry, then adjust for any ASYNC_WRITE or ASYNC_TRUNCATE operations

** currently in the write-op list.

**

** This method holds the mutex from start to finish.

*/

int asyncFileSize(sqlite3_file *pFile, sqlite3_int64 *piSize){

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

int rc = SQLITE_OK;

sqlite3_int64 s = 0;

sqlite3_file *pBase;

async_mutex_enter(ASYNC_MUTEX_QUEUE);

/* Read the filesystem size from the base file. If pMethods is NULL, this

** means the file hasn't been opened yet. In this case all relevant data

** must be in the write-op queue anyway, so we can omit reading from the

** file-system.

*/

pBase = p->pBaseRead;

if( pBase->pMethods ){

rc = pBase->pMethods->xFileSize(pBase, &s);

}

if( rc==SQLITE_OK ){

AsyncWrite *pWrite;

for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){

if( pWrite->op==ASYNC_DELETE

&& p->zName

&& strcmp(p->zName, pWrite->zBuf)==0

){

s = 0;

}else if( pWrite->pFileData && (

(pWrite->pFileData==p)

|| (p->zName && pWrite->pFileData->zName==p->zName)

)){

switch( pWrite->op ){

case ASYNC_WRITE:

s = MAX(pWrite->iOffset + (sqlite3_int64)(pWrite->nByte), s);

break;

case ASYNC_TRUNCATE:

s = MIN(s, pWrite->iOffset);

break;

}

}

}

*piSize = s;

}

async_mutex_leave(ASYNC_MUTEX_QUEUE);

return rc;

}

/*

** Lock or unlock the actual file-system entry.

*/

static int getFileLock(AsyncLock *pLock){

int rc = SQLITE_OK;

AsyncFileLock *pIter;

int eRequired = 0;

if( pLock->pFile ){

for(pIter=pLock->pList; pIter; pIter=pIter->pNext){

assert(pIter->eAsyncLock>=pIter->eLock);

if( pIter->eAsyncLock>eRequired ){

eRequired = pIter->eAsyncLock;

assert(eRequired>=0 && eRequired<=SQLITE_LOCK_EXCLUSIVE);

}

}

if( eRequired>pLock->eLock ){

rc = pLock->pFile->pMethods->xLock(pLock->pFile, eRequired);

if( rc==SQLITE_OK ){

pLock->eLock = eRequired;

}

}

else if( eRequired<pLock->eLock && eRequired<=SQLITE_LOCK_SHARED ){

rc = pLock->pFile->pMethods->xUnlock(pLock->pFile, eRequired);

if( rc==SQLITE_OK ){

pLock->eLock = eRequired;

}

}

}

return rc;

}

/*

** Return the AsyncLock structure from the global async.pLock list

** associated with the file-system entry identified by path zName

** (a string of nName bytes). If no such structure exists, return 0.

*/

static AsyncLock *findLock(const char *zName, int nName){

AsyncLock *p = async.pLock;

while( p && (p->nFile!=nName || memcmp(p->zFile, zName, nName)) ){

p = p->pNext;

}

return p;

}

/*

** The following two methods - asyncLock() and asyncUnlock() - are used

** to obtain and release locks on database files opened with the

** asynchronous backend.

*/

static int asyncLock(sqlite3_file *pFile, int eLock){

int rc = SQLITE_OK;

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

if( p->zName ){

async_mutex_enter(ASYNC_MUTEX_LOCK);

if( p->lock.eLock<eLock ){

AsyncLock *pLock = p->pLock;

AsyncFileLock *pIter;

assert(pLock && pLock->pList);

for(pIter=pLock->pList; pIter; pIter=pIter->pNext){

if( pIter!=&p->lock && (

(eLock==SQLITE_LOCK_EXCLUSIVE && pIter->eLock>=SQLITE_LOCK_SHARED) ||

(eLock==SQLITE_LOCK_PENDING && pIter->eLock>=SQLITE_LOCK_RESERVED) ||

(eLock==SQLITE_LOCK_RESERVED && pIter->eLock>=SQLITE_LOCK_RESERVED) ||

(eLock==SQLITE_LOCK_SHARED && pIter->eLock>=SQLITE_LOCK_PENDING)

)){

rc = SQLITE_BUSY;

}

}

if( rc==SQLITE_OK ){

p->lock.eLock = eLock;

p->lock.eAsyncLock = MAX(p->lock.eAsyncLock, eLock);

}

assert(p->lock.eAsyncLock>=p->lock.eLock);

if( rc==SQLITE_OK ){

rc = getFileLock(pLock);

}

}

async_mutex_leave(ASYNC_MUTEX_LOCK);

}

ASYNC_TRACE(("LOCK %d (%s) rc=%d\n", eLock, p->zName, rc));

return rc;

}

static int asyncUnlock(sqlite3_file *pFile, int eLock){

int rc = SQLITE_OK;

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

if( p->zName ){

AsyncFileLock *pLock = &p->lock;

async_mutex_enter(ASYNC_MUTEX_QUEUE);

async_mutex_enter(ASYNC_MUTEX_LOCK);

pLock->eLock = MIN(pLock->eLock, eLock);

rc = addNewAsyncWrite(p, ASYNC_UNLOCK, 0, eLock, 0);

async_mutex_leave(ASYNC_MUTEX_LOCK);

async_mutex_leave(ASYNC_MUTEX_QUEUE);

}

return rc;

}

/*

** This function is called when the pager layer first opens a database file

** and is checking for a hot-journal.

*/

static int asyncCheckReservedLock(sqlite3_file *pFile, int *pResOut){

int ret = 0;

AsyncFileLock *pIter;

AsyncFileData *p = ((AsyncFile *)pFile)->pData;

async_mutex_enter(ASYNC_MUTEX_LOCK);

for(pIter=p->pLock->pList; pIter; pIter=pIter->pNext){

if( pIter->eLock>=SQLITE_LOCK_RESERVED ){

ret = 1;

break;

}

}

async_mutex_leave(ASYNC_MUTEX_LOCK);

ASYNC_TRACE(("CHECK-LOCK %d (%s)\n", ret, p->zName));

*pResOut = ret;

return SQLITE_OK;

}

/*

** sqlite3_file_control() implementation.

*/

static int asyncFileControl(sqlite3_file *id, int op, void *pArg){

switch( op ){

case SQLITE_FCNTL_LOCKSTATE: {

async_mutex_enter(ASYNC_MUTEX_LOCK);

*(int*)pArg = ((AsyncFile*)id)->pData->lock.eLock;

async_mutex_leave(ASYNC_MUTEX_LOCK);

return SQLITE_OK;

}

}

return SQLITE_NOTFOUND;

}

/*

** Return the device characteristics and sector-size of the device. It

** is tricky to implement these correctly, as this backend might

** not have an open file handle at this point.

*/

static int asyncSectorSize(sqlite3_file *pFile){

UNUSED_PARAMETER(pFile);

return 512;

}

static int asyncDeviceCharacteristics(sqlite3_file *pFile){

UNUSED_PARAMETER(pFile);

return 0;

}

static int unlinkAsyncFile(AsyncFileData *pData){

AsyncFileLock **ppIter;

int rc = SQLITE_OK;

if( pData->zName ){

AsyncLock *pLock = pData->pLock;

for(ppIter=&pLock->pList; *ppIter; ppIter=&((*ppIter)->pNext)){

if( (*ppIter)==&pData->lock ){

*ppIter = pData->lock.pNext;

break;

}

}

if( !pLock->pList ){

AsyncLock **pp;

if( pLock->pFile ){

pLock->pFile->pMethods->xClose(pLock->pFile);

}

for(pp=&async.pLock; *pp!=pLock; pp=&((*pp)->pNext));

*pp = pLock->pNext;

sqlite3_free(pLock);

}else{

rc = getFileLock(pLock);

}

}

return rc;

}

/*

** The parameter passed to this function is a copy of a 'flags' parameter

** passed to this modules xOpen() method. This function returns true

** if the file should be opened asynchronously, or false if it should

** be opened immediately.

**

** If the file is to be opened asynchronously, then asyncOpen() will add

** an entry to the event queue and the file will not actually be opened

** until the event is processed. Otherwise, the file is opened directly