Home | History | Annotate | Download | only in src 
      1 /*
      2 ** 2008 October 7
      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 ** This file contains code use to implement an in-memory rollback journal.
     14 ** The in-memory rollback journal is used to journal transactions for
     15 ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
     16 */
     17 #include "sqliteInt.h"
     18 
     19 /* Forward references to internal structures */
     20 typedef struct MemJournal MemJournal;
     21 typedef struct FilePoint FilePoint;
     22 typedef struct FileChunk FileChunk;
     23 
     24 /* Space to hold the rollback journal is allocated in increments of
     25 ** this many bytes.
     26 **
     27 ** The size chosen is a little less than a power of two.  That way,
     28 ** the FileChunk object will have a size that almost exactly fills
     29 ** a power-of-two allocation.  This mimimizes wasted space in power-of-two
     30 ** memory allocators.
     31 */
     32 #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
     33 
     34 /* Macro to find the minimum of two numeric values.
     35 */
     36 #ifndef MIN
     37 # define MIN(x,y) ((x)<(y)?(x):(y))
     38 #endif
     39 
     40 /*
     41 ** The rollback journal is composed of a linked list of these structures.
     42 */
     43 struct FileChunk {
     44   FileChunk *pNext;               /* Next chunk in the journal */
     45   u8 zChunk[JOURNAL_CHUNKSIZE];   /* Content of this chunk */
     46 };
     47 
     48 /*
     49 ** An instance of this object serves as a cursor into the rollback journal.
     50 ** The cursor can be either for reading or writing.
     51 */
     52 struct FilePoint {
     53   sqlite3_int64 iOffset;          /* Offset from the beginning of the file */
     54   FileChunk *pChunk;              /* Specific chunk into which cursor points */
     55 };
     56 
     57 /*
     58 ** This subclass is a subclass of sqlite3_file.  Each open memory-journal
     59 ** is an instance of this class.
     60 */
     61 struct MemJournal {
     62   sqlite3_io_methods *pMethod;    /* Parent class. MUST BE FIRST */
     63   FileChunk *pFirst;              /* Head of in-memory chunk-list */
     64   FilePoint endpoint;             /* Pointer to the end of the file */
     65   FilePoint readpoint;            /* Pointer to the end of the last xRead() */
     66 };
     67 
     68 /*
     69 ** Read data from the in-memory journal file.  This is the implementation
     70 ** of the sqlite3_vfs.xRead method.
     71 */
     72 static int memjrnlRead(
     73   sqlite3_file *pJfd,    /* The journal file from which to read */
     74   void *zBuf,            /* Put the results here */
     75   int iAmt,              /* Number of bytes to read */
     76   sqlite_int64 iOfst     /* Begin reading at this offset */
     77 ){
     78   MemJournal *p = (MemJournal *)pJfd;
     79   u8 *zOut = zBuf;
     80   int nRead = iAmt;
     81   int iChunkOffset;
     82   FileChunk *pChunk;
     83 
     84   /* SQLite never tries to read past the end of a rollback journal file */
     85   assert( iOfst+iAmt<=p->endpoint.iOffset );
     86 
     87   if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
     88     sqlite3_int64 iOff = 0;
     89     for(pChunk=p->pFirst;
     90         ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
     91         pChunk=pChunk->pNext
     92     ){
     93       iOff += JOURNAL_CHUNKSIZE;
     94     }
     95   }else{
     96     pChunk = p->readpoint.pChunk;
     97   }
     98 
     99   iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE);
    100   do {
    101     int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
    102     int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset));
    103     memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy);
    104     zOut += nCopy;
    105     nRead -= iSpace;
    106     iChunkOffset = 0;
    107   } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
    108   p->readpoint.iOffset = iOfst+iAmt;
    109   p->readpoint.pChunk = pChunk;
    110 
    111   return SQLITE_OK;
    112 }
    113 
    114 /*
    115 ** Write data to the file.
    116 */
    117 static int memjrnlWrite(
    118   sqlite3_file *pJfd,    /* The journal file into which to write */
    119   const void *zBuf,      /* Take data to be written from here */
    120   int iAmt,              /* Number of bytes to write */
    121   sqlite_int64 iOfst     /* Begin writing at this offset into the file */
    122 ){
    123   MemJournal *p = (MemJournal *)pJfd;
    124   int nWrite = iAmt;
    125   u8 *zWrite = (u8 *)zBuf;
    126 
    127   /* An in-memory journal file should only ever be appended to. Random
    128   ** access writes are not required by sqlite.
    129   */
    130   assert( iOfst==p->endpoint.iOffset );
    131   UNUSED_PARAMETER(iOfst);
    132 
    133   while( nWrite>0 ){
    134     FileChunk *pChunk = p->endpoint.pChunk;
    135     int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
    136     int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
    137 
    138     if( iChunkOffset==0 ){
    139       /* New chunk is required to extend the file. */
    140       FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
    141       if( !pNew ){
    142         return SQLITE_IOERR_NOMEM;
    143       }
    144       pNew->pNext = 0;
    145       if( pChunk ){
    146         assert( p->pFirst );
    147         pChunk->pNext = pNew;
    148       }else{
    149         assert( !p->pFirst );
    150         p->pFirst = pNew;
    151       }
    152       p->endpoint.pChunk = pNew;
    153     }
    154 
    155     memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
    156     zWrite += iSpace;
    157     nWrite -= iSpace;
    158     p->endpoint.iOffset += iSpace;
    159   }
    160 
    161   return SQLITE_OK;
    162 }
    163 
    164 /*
    165 ** Truncate the file.
    166 */
    167 static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
    168   MemJournal *p = (MemJournal *)pJfd;
    169   FileChunk *pChunk;
    170   assert(size==0);
    171   UNUSED_PARAMETER(size);
    172   pChunk = p->pFirst;
    173   while( pChunk ){
    174     FileChunk *pTmp = pChunk;
    175     pChunk = pChunk->pNext;
    176     sqlite3_free(pTmp);
    177   }
    178   sqlite3MemJournalOpen(pJfd);
    179   return SQLITE_OK;
    180 }
    181 
    182 /*
    183 ** Close the file.
    184 */
    185 static int memjrnlClose(sqlite3_file *pJfd){
    186   memjrnlTruncate(pJfd, 0);
    187   return SQLITE_OK;
    188 }
    189 
    190 
    191 /*
    192 ** Sync the file.
    193 **
    194 ** Syncing an in-memory journal is a no-op.  And, in fact, this routine
    195 ** is never called in a working implementation.  This implementation
    196 ** exists purely as a contingency, in case some malfunction in some other
    197 ** part of SQLite causes Sync to be called by mistake.
    198 */
    199 static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){
    200   UNUSED_PARAMETER2(NotUsed, NotUsed2);
    201   return SQLITE_OK;
    202 }
    203 
    204 /*
    205 ** Query the size of the file in bytes.
    206 */
    207 static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
    208   MemJournal *p = (MemJournal *)pJfd;
    209   *pSize = (sqlite_int64) p->endpoint.iOffset;
    210   return SQLITE_OK;
    211 }
    212 
    213 /*
    214 ** Table of methods for MemJournal sqlite3_file object.
    215 */
    216 static const struct sqlite3_io_methods MemJournalMethods = {
    217   1,                /* iVersion */
    218   memjrnlClose,     /* xClose */
    219   memjrnlRead,      /* xRead */
    220   memjrnlWrite,     /* xWrite */
    221   memjrnlTruncate,  /* xTruncate */
    222   memjrnlSync,      /* xSync */
    223   memjrnlFileSize,  /* xFileSize */
    224   0,                /* xLock */
    225   0,                /* xUnlock */
    226   0,                /* xCheckReservedLock */
    227   0,                /* xFileControl */
    228   0,                /* xSectorSize */
    229   0,                /* xDeviceCharacteristics */
    230   0,                /* xShmMap */
    231   0,                /* xShmLock */
    232   0,                /* xShmBarrier */
    233   0                 /* xShmUnlock */
    234 };
    235 
    236 /*
    237 ** Open a journal file.
    238 */
    239 void sqlite3MemJournalOpen(sqlite3_file *pJfd){
    240   MemJournal *p = (MemJournal *)pJfd;
    241   assert( EIGHT_BYTE_ALIGNMENT(p) );
    242   memset(p, 0, sqlite3MemJournalSize());
    243   p->pMethod = (sqlite3_io_methods*)&MemJournalMethods;
    244 }
    245 
    246 /*
    247 ** Return true if the file-handle passed as an argument is
    248 ** an in-memory journal
    249 */
    250 int sqlite3IsMemJournal(sqlite3_file *pJfd){
    251   return pJfd->pMethods==&MemJournalMethods;
    252 }
    253 
    254 /*
    255 ** Return the number of bytes required to store a MemJournal file descriptor.
    256 */
    257 int sqlite3MemJournalSize(void){
    258   return sizeof(MemJournal);
    259 }
    260