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