/*

 ** 2007 August 22

 **

 ** 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: journal.c,v 1.8 2008/05/01 18:01:47 drh Exp $

 */

 #ifdef SQLITE_ENABLE_ATOMIC_WRITE

 /*

 ** This file implements a special kind of sqlite3_file object used

 ** by SQLite to create journal files if the atomic-write optimization

 ** is enabled.

 **

 ** The distinctive characteristic of this sqlite3_file is that the

 ** actual on disk file is created lazily. When the file is created,

 ** the caller specifies a buffer size for an in-memory buffer to

 ** be used to service read() and write() requests. The actual file

 ** on disk is not created or populated until either:

 **

 **   1) The in-memory representation grows too large for the allocated 

 **      buffer, or

 **   2) The xSync() method is called.

 */

 #include "sqliteInt.h"

 /*

 ** A JournalFile object is a subclass of sqlite3_file used by

 ** as an open file handle for journal files.

 */

 struct JournalFile {

   sqlite3_io_methods *pMethod;    /* I/O methods on journal files */

   int nBuf;                       /* Size of zBuf[] in bytes */

   char *zBuf;                     /* Space to buffer journal writes */

   int iSize;                      /* Amount of zBuf[] currently used */

   int flags;                      /* xOpen flags */

   sqlite3_vfs *pVfs;              /* The "real" underlying VFS */

   sqlite3_file *pReal;            /* The "real" underlying file descriptor */

   const char *zJournal;           /* Name of the journal file */

 };

 typedef struct JournalFile JournalFile;

 /*

 ** If it does not already exists, create and populate the on-disk file 

 ** for JournalFile p.

 */

 static int createFile(JournalFile *p){

   int rc = SQLITE_OK;

   if( !p->pReal ){

     sqlite3_file *pReal = (sqlite3_file *)&p[1];

     rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);

     if( rc==SQLITE_OK ){

       p->pReal = pReal;

       if( p->iSize>0 ){

         assert(p->iSize<=p->nBuf);

         rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);

       }

     }

   }

   return rc;

 }

 /*

 ** Close the file.

 */

 static int jrnlClose(sqlite3_file *pJfd){

   JournalFile *p = (JournalFile *)pJfd;

   if( p->pReal ){

     sqlite3OsClose(p->pReal);

   }

   sqlite3_free(p->zBuf);

   return SQLITE_OK;

 }

 /*

 ** Read data from the file.

 */

 static int jrnlRead(

   sqlite3_file *pJfd,    /* The journal file from which to read */

   void *zBuf,            /* Put the results here */

   int iAmt,              /* Number of bytes to read */

   sqlite_int64 iOfst     /* Begin reading at this offset */

 ){

   int rc = SQLITE_OK;

   JournalFile *p = (JournalFile *)pJfd;

   if( p->pReal ){

     rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);

   }else{

     assert( iAmt+iOfst<=p->iSize );

     memcpy(zBuf, &p->zBuf[iOfst], iAmt);

   }

   return rc;

 }

 /*

 ** Write data to the file.

 */

 static int jrnlWrite(

   sqlite3_file *pJfd,    /* The journal file into which to write */

   const void *zBuf,      /* Take data to be written from here */

   int iAmt,              /* Number of bytes to write */

   sqlite_int64 iOfst     /* Begin writing at this offset into the file */

 ){

   int rc = SQLITE_OK;

   JournalFile *p = (JournalFile *)pJfd;

   if( !p->pReal && (iOfst+iAmt)>p->nBuf ){

     rc = createFile(p);

   }

   if( rc==SQLITE_OK ){

     if( p->pReal ){

       rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);

     }else{

       memcpy(&p->zBuf[iOfst], zBuf, iAmt);

       if( p->iSize<(iOfst+iAmt) ){

         p->iSize = (iOfst+iAmt);

       }

     }

   }

   return rc;

 }

 /*

 ** Truncate the file.

 */

 static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){

   int rc = SQLITE_OK;

   JournalFile *p = (JournalFile *)pJfd;

   if( p->pReal ){

     rc = sqlite3OsTruncate(p->pReal, size);

   }else if( size<p->iSize ){

     p->iSize = size;

   }

   return rc;

 }

 /*

 ** Sync the file.

 */

 static int jrnlSync(sqlite3_file *pJfd, int flags){

   int rc;

   JournalFile *p = (JournalFile *)pJfd;

   if( p->pReal ){

     rc = sqlite3OsSync(p->pReal, flags);

   }else{

     rc = SQLITE_OK;

   }

   return rc;

 }

 /*

 ** Query the size of the file in bytes.

 */

 static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){

   int rc = SQLITE_OK;

   JournalFile *p = (JournalFile *)pJfd;

   if( p->pReal ){

     rc = sqlite3OsFileSize(p->pReal, pSize);

   }else{

     *pSize = (sqlite_int64) p->iSize;

   }

   return rc;

 }

 /*

 ** Table of methods for JournalFile sqlite3_file object.

 */

 static struct sqlite3_io_methods JournalFileMethods = {

   1,             /* iVersion */

   jrnlClose,     /* xClose */

   jrnlRead,      /* xRead */

   jrnlWrite,     /* xWrite */

   jrnlTruncate,  /* xTruncate */

   jrnlSync,      /* xSync */

   jrnlFileSize,  /* xFileSize */

   0,             /* xLock */

   0,             /* xUnlock */

   0,             /* xCheckReservedLock */

   0,             /* xFileControl */

   0,             /* xSectorSize */

   0              /* xDeviceCharacteristics */

 };

 /* 

 ** Open a journal file.

 */

 int sqlite3JournalOpen(

   sqlite3_vfs *pVfs,         /* The VFS to use for actual file I/O */

   const char *zName,         /* Name of the journal file */

   sqlite3_file *pJfd,        /* Preallocated, blank file handle */

   int flags,                 /* Opening flags */

   int nBuf                   /* Bytes buffered before opening the file */

 ){

   JournalFile *p = (JournalFile *)pJfd;

   memset(p, 0, sqlite3JournalSize(pVfs));

   if( nBuf>0 ){

     p->zBuf = sqlite3MallocZero(nBuf);

     if( !p->zBuf ){

       return SQLITE_NOMEM;

     }

   }else{

     return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);

   }

   p->pMethod = &JournalFileMethods;

   p->nBuf = nBuf;

   p->flags = flags;

   p->zJournal = zName;

   p->pVfs = pVfs;

   return SQLITE_OK;

 }

 /*

 ** If the argument p points to a JournalFile structure, and the underlying

 ** file has not yet been created, create it now.

 */

 int sqlite3JournalCreate(sqlite3_file *p){

   if( p->pMethods!=&JournalFileMethods ){

     return SQLITE_OK;

   }

   return createFile((JournalFile *)p);

 }

 /* 

 ** Return the number of bytes required to store a JournalFile that uses vfs

 ** pVfs to create the underlying on-disk files.

 */

 int sqlite3JournalSize(sqlite3_vfs *pVfs){

   return (pVfs->szOsFile+sizeof(JournalFile));

 }

 #endif