1/*
2** 2007 August 22
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 implements a special kind of sqlite3_file object used
14** by SQLite to create journal files if the atomic-write optimization
15** is enabled.
16**
17** The distinctive characteristic of this sqlite3_file is that the
18** actual on disk file is created lazily. When the file is created,
19** the caller specifies a buffer size for an in-memory buffer to
20** be used to service read() and write() requests. The actual file
21** on disk is not created or populated until either:
22**
23**   1) The in-memory representation grows too large for the allocated
24**      buffer, or
25**   2) The sqlite3JournalCreate() function is called.
26*/
27#ifdef SQLITE_ENABLE_ATOMIC_WRITE
28#include "sqliteInt.h"
29
30
31/*
32** A JournalFile object is a subclass of sqlite3_file used by
33** as an open file handle for journal files.
34*/
35struct JournalFile {
36  sqlite3_io_methods *pMethod;    /* I/O methods on journal files */
37  int nBuf;                       /* Size of zBuf[] in bytes */
38  char *zBuf;                     /* Space to buffer journal writes */
39  int iSize;                      /* Amount of zBuf[] currently used */
40  int flags;                      /* xOpen flags */
41  sqlite3_vfs *pVfs;              /* The "real" underlying VFS */
42  sqlite3_file *pReal;            /* The "real" underlying file descriptor */
43  const char *zJournal;           /* Name of the journal file */
44};
45typedef struct JournalFile JournalFile;
46
47/*
48** If it does not already exists, create and populate the on-disk file
49** for JournalFile p.
50*/
51static int createFile(JournalFile *p){
52  int rc = SQLITE_OK;
53  if( !p->pReal ){
54    sqlite3_file *pReal = (sqlite3_file *)&p[1];
55    rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
56    if( rc==SQLITE_OK ){
57      p->pReal = pReal;
58      if( p->iSize>0 ){
59        assert(p->iSize<=p->nBuf);
60        rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
61      }
62    }
63  }
64  return rc;
65}
66
67/*
68** Close the file.
69*/
70static int jrnlClose(sqlite3_file *pJfd){
71  JournalFile *p = (JournalFile *)pJfd;
72  if( p->pReal ){
73    sqlite3OsClose(p->pReal);
74  }
75  sqlite3_free(p->zBuf);
76  return SQLITE_OK;
77}
78
79/*
80** Read data from the file.
81*/
82static int jrnlRead(
83  sqlite3_file *pJfd,    /* The journal file from which to read */
84  void *zBuf,            /* Put the results here */
85  int iAmt,              /* Number of bytes to read */
86  sqlite_int64 iOfst     /* Begin reading at this offset */
87){
88  int rc = SQLITE_OK;
89  JournalFile *p = (JournalFile *)pJfd;
90  if( p->pReal ){
91    rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
92  }else if( (iAmt+iOfst)>p->iSize ){
93    rc = SQLITE_IOERR_SHORT_READ;
94  }else{
95    memcpy(zBuf, &p->zBuf[iOfst], iAmt);
96  }
97  return rc;
98}
99
100/*
101** Write data to the file.
102*/
103static int jrnlWrite(
104  sqlite3_file *pJfd,    /* The journal file into which to write */
105  const void *zBuf,      /* Take data to be written from here */
106  int iAmt,              /* Number of bytes to write */
107  sqlite_int64 iOfst     /* Begin writing at this offset into the file */
108){
109  int rc = SQLITE_OK;
110  JournalFile *p = (JournalFile *)pJfd;
111  if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
112    rc = createFile(p);
113  }
114  if( rc==SQLITE_OK ){
115    if( p->pReal ){
116      rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
117    }else{
118      memcpy(&p->zBuf[iOfst], zBuf, iAmt);
119      if( p->iSize<(iOfst+iAmt) ){
120        p->iSize = (iOfst+iAmt);
121      }
122    }
123  }
124  return rc;
125}
126
127/*
128** Truncate the file.
129*/
130static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
131  int rc = SQLITE_OK;
132  JournalFile *p = (JournalFile *)pJfd;
133  if( p->pReal ){
134    rc = sqlite3OsTruncate(p->pReal, size);
135  }else if( size<p->iSize ){
136    p->iSize = size;
137  }
138  return rc;
139}
140
141/*
142** Sync the file.
143*/
144static int jrnlSync(sqlite3_file *pJfd, int flags){
145  int rc;
146  JournalFile *p = (JournalFile *)pJfd;
147  if( p->pReal ){
148    rc = sqlite3OsSync(p->pReal, flags);
149  }else{
150    rc = SQLITE_OK;
151  }
152  return rc;
153}
154
155/*
156** Query the size of the file in bytes.
157*/
158static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
159  int rc = SQLITE_OK;
160  JournalFile *p = (JournalFile *)pJfd;
161  if( p->pReal ){
162    rc = sqlite3OsFileSize(p->pReal, pSize);
163  }else{
164    *pSize = (sqlite_int64) p->iSize;
165  }
166  return rc;
167}
168
169/*
170** Table of methods for JournalFile sqlite3_file object.
171*/
172static struct sqlite3_io_methods JournalFileMethods = {
173  1,             /* iVersion */
174  jrnlClose,     /* xClose */
175  jrnlRead,      /* xRead */
176  jrnlWrite,     /* xWrite */
177  jrnlTruncate,  /* xTruncate */
178  jrnlSync,      /* xSync */
179  jrnlFileSize,  /* xFileSize */
180  0,             /* xLock */
181  0,             /* xUnlock */
182  0,             /* xCheckReservedLock */
183  0,             /* xFileControl */
184  0,             /* xSectorSize */
185  0,             /* xDeviceCharacteristics */
186  0,             /* xShmMap */
187  0,             /* xShmLock */
188  0,             /* xShmBarrier */
189  0              /* xShmUnmap */
190};
191
192/*
193** Open a journal file.
194*/
195int sqlite3JournalOpen(
196  sqlite3_vfs *pVfs,         /* The VFS to use for actual file I/O */
197  const char *zName,         /* Name of the journal file */
198  sqlite3_file *pJfd,        /* Preallocated, blank file handle */
199  int flags,                 /* Opening flags */
200  int nBuf                   /* Bytes buffered before opening the file */
201){
202  JournalFile *p = (JournalFile *)pJfd;
203  memset(p, 0, sqlite3JournalSize(pVfs));
204  if( nBuf>0 ){
205    p->zBuf = sqlite3MallocZero(nBuf);
206    if( !p->zBuf ){
207      return SQLITE_NOMEM;
208    }
209  }else{
210    return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
211  }
212  p->pMethod = &JournalFileMethods;
213  p->nBuf = nBuf;
214  p->flags = flags;
215  p->zJournal = zName;
216  p->pVfs = pVfs;
217  return SQLITE_OK;
218}
219
220/*
221** If the argument p points to a JournalFile structure, and the underlying
222** file has not yet been created, create it now.
223*/
224int sqlite3JournalCreate(sqlite3_file *p){
225  if( p->pMethods!=&JournalFileMethods ){
226    return SQLITE_OK;
227  }
228  return createFile((JournalFile *)p);
229}
230
231/*
232** Return the number of bytes required to store a JournalFile that uses vfs
233** pVfs to create the underlying on-disk files.
234*/
235int sqlite3JournalSize(sqlite3_vfs *pVfs){
236  return (pVfs->szOsFile+sizeof(JournalFile));
237}
238#endif
239