1 | /* |
2 | ** 2009 January 28 |
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 | ** This file contains the implementation of the sqlite3_backup_XXX() |
13 | ** API functions and the related features. |
14 | */ |
15 | #include "sqliteInt.h" |
16 | #include "btreeInt.h" |
17 | |
18 | /* |
19 | ** Structure allocated for each backup operation. |
20 | */ |
21 | struct sqlite3_backup { |
22 | sqlite3* pDestDb; /* Destination database handle */ |
23 | Btree *pDest; /* Destination b-tree file */ |
24 | u32 iDestSchema; /* Original schema cookie in destination */ |
25 | int bDestLocked; /* True once a write-transaction is open on pDest */ |
26 | |
27 | Pgno iNext; /* Page number of the next source page to copy */ |
28 | sqlite3* pSrcDb; /* Source database handle */ |
29 | Btree *pSrc; /* Source b-tree file */ |
30 | |
31 | int rc; /* Backup process error code */ |
32 | |
33 | /* These two variables are set by every call to backup_step(). They are |
34 | ** read by calls to backup_remaining() and backup_pagecount(). |
35 | */ |
36 | Pgno nRemaining; /* Number of pages left to copy */ |
37 | Pgno nPagecount; /* Total number of pages to copy */ |
38 | |
39 | int isAttached; /* True once backup has been registered with pager */ |
40 | sqlite3_backup *pNext; /* Next backup associated with source pager */ |
41 | }; |
42 | |
43 | /* |
44 | ** THREAD SAFETY NOTES: |
45 | ** |
46 | ** Once it has been created using backup_init(), a single sqlite3_backup |
47 | ** structure may be accessed via two groups of thread-safe entry points: |
48 | ** |
49 | ** * Via the sqlite3_backup_XXX() API function backup_step() and |
50 | ** backup_finish(). Both these functions obtain the source database |
51 | ** handle mutex and the mutex associated with the source BtShared |
52 | ** structure, in that order. |
53 | ** |
54 | ** * Via the BackupUpdate() and BackupRestart() functions, which are |
55 | ** invoked by the pager layer to report various state changes in |
56 | ** the page cache associated with the source database. The mutex |
57 | ** associated with the source database BtShared structure will always |
58 | ** be held when either of these functions are invoked. |
59 | ** |
60 | ** The other sqlite3_backup_XXX() API functions, backup_remaining() and |
61 | ** backup_pagecount() are not thread-safe functions. If they are called |
62 | ** while some other thread is calling backup_step() or backup_finish(), |
63 | ** the values returned may be invalid. There is no way for a call to |
64 | ** BackupUpdate() or BackupRestart() to interfere with backup_remaining() |
65 | ** or backup_pagecount(). |
66 | ** |
67 | ** Depending on the SQLite configuration, the database handles and/or |
68 | ** the Btree objects may have their own mutexes that require locking. |
69 | ** Non-sharable Btrees (in-memory databases for example), do not have |
70 | ** associated mutexes. |
71 | */ |
72 | |
73 | /* |
74 | ** Return a pointer corresponding to database zDb (i.e. "main", "temp") |
75 | ** in connection handle pDb. If such a database cannot be found, return |
76 | ** a NULL pointer and write an error message to pErrorDb. |
77 | ** |
78 | ** If the "temp" database is requested, it may need to be opened by this |
79 | ** function. If an error occurs while doing so, return 0 and write an |
80 | ** error message to pErrorDb. |
81 | */ |
82 | static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){ |
83 | int i = sqlite3FindDbName(pDb, zDb); |
84 | |
85 | if( i==1 ){ |
86 | Parse sParse; |
87 | int rc = 0; |
88 | sqlite3ParseObjectInit(&sParse,pDb); |
89 | if( sqlite3OpenTempDatabase(&sParse) ){ |
90 | sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s" , sParse.zErrMsg); |
91 | rc = SQLITE_ERROR; |
92 | } |
93 | sqlite3DbFree(pErrorDb, sParse.zErrMsg); |
94 | sqlite3ParseObjectReset(&sParse); |
95 | if( rc ){ |
96 | return 0; |
97 | } |
98 | } |
99 | |
100 | if( i<0 ){ |
101 | sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s" , zDb); |
102 | return 0; |
103 | } |
104 | |
105 | return pDb->aDb[i].pBt; |
106 | } |
107 | |
108 | /* |
109 | ** Attempt to set the page size of the destination to match the page size |
110 | ** of the source. |
111 | */ |
112 | static int setDestPgsz(sqlite3_backup *p){ |
113 | int rc; |
114 | rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),0,0); |
115 | return rc; |
116 | } |
117 | |
118 | /* |
119 | ** Check that there is no open read-transaction on the b-tree passed as the |
120 | ** second argument. If there is not, return SQLITE_OK. Otherwise, if there |
121 | ** is an open read-transaction, return SQLITE_ERROR and leave an error |
122 | ** message in database handle db. |
123 | */ |
124 | static int checkReadTransaction(sqlite3 *db, Btree *p){ |
125 | if( sqlite3BtreeTxnState(p)!=SQLITE_TXN_NONE ){ |
126 | sqlite3ErrorWithMsg(db, SQLITE_ERROR, "destination database is in use" ); |
127 | return SQLITE_ERROR; |
128 | } |
129 | return SQLITE_OK; |
130 | } |
131 | |
132 | /* |
133 | ** Create an sqlite3_backup process to copy the contents of zSrcDb from |
134 | ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return |
135 | ** a pointer to the new sqlite3_backup object. |
136 | ** |
137 | ** If an error occurs, NULL is returned and an error code and error message |
138 | ** stored in database handle pDestDb. |
139 | */ |
140 | sqlite3_backup *sqlite3_backup_init( |
141 | sqlite3* pDestDb, /* Database to write to */ |
142 | const char *zDestDb, /* Name of database within pDestDb */ |
143 | sqlite3* pSrcDb, /* Database connection to read from */ |
144 | const char *zSrcDb /* Name of database within pSrcDb */ |
145 | ){ |
146 | sqlite3_backup *p; /* Value to return */ |
147 | |
148 | #ifdef SQLITE_ENABLE_API_ARMOR |
149 | if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){ |
150 | (void)SQLITE_MISUSE_BKPT; |
151 | return 0; |
152 | } |
153 | #endif |
154 | |
155 | /* Lock the source database handle. The destination database |
156 | ** handle is not locked in this routine, but it is locked in |
157 | ** sqlite3_backup_step(). The user is required to ensure that no |
158 | ** other thread accesses the destination handle for the duration |
159 | ** of the backup operation. Any attempt to use the destination |
160 | ** database connection while a backup is in progress may cause |
161 | ** a malfunction or a deadlock. |
162 | */ |
163 | sqlite3_mutex_enter(pSrcDb->mutex); |
164 | sqlite3_mutex_enter(pDestDb->mutex); |
165 | |
166 | if( pSrcDb==pDestDb ){ |
167 | sqlite3ErrorWithMsg( |
168 | pDestDb, SQLITE_ERROR, "source and destination must be distinct" |
169 | ); |
170 | p = 0; |
171 | }else { |
172 | /* Allocate space for a new sqlite3_backup object... |
173 | ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a |
174 | ** call to sqlite3_backup_init() and is destroyed by a call to |
175 | ** sqlite3_backup_finish(). */ |
176 | p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup)); |
177 | if( !p ){ |
178 | sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT); |
179 | } |
180 | } |
181 | |
182 | /* If the allocation succeeded, populate the new object. */ |
183 | if( p ){ |
184 | p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb); |
185 | p->pDest = findBtree(pDestDb, pDestDb, zDestDb); |
186 | p->pDestDb = pDestDb; |
187 | p->pSrcDb = pSrcDb; |
188 | p->iNext = 1; |
189 | p->isAttached = 0; |
190 | |
191 | if( 0==p->pSrc || 0==p->pDest |
192 | || checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK |
193 | ){ |
194 | /* One (or both) of the named databases did not exist or an OOM |
195 | ** error was hit. Or there is a transaction open on the destination |
196 | ** database. The error has already been written into the pDestDb |
197 | ** handle. All that is left to do here is free the sqlite3_backup |
198 | ** structure. */ |
199 | sqlite3_free(p); |
200 | p = 0; |
201 | } |
202 | } |
203 | if( p ){ |
204 | p->pSrc->nBackup++; |
205 | } |
206 | |
207 | sqlite3_mutex_leave(pDestDb->mutex); |
208 | sqlite3_mutex_leave(pSrcDb->mutex); |
209 | return p; |
210 | } |
211 | |
212 | /* |
213 | ** Argument rc is an SQLite error code. Return true if this error is |
214 | ** considered fatal if encountered during a backup operation. All errors |
215 | ** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED. |
216 | */ |
217 | static int isFatalError(int rc){ |
218 | return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED)); |
219 | } |
220 | |
221 | /* |
222 | ** Parameter zSrcData points to a buffer containing the data for |
223 | ** page iSrcPg from the source database. Copy this data into the |
224 | ** destination database. |
225 | */ |
226 | static int backupOnePage( |
227 | sqlite3_backup *p, /* Backup handle */ |
228 | Pgno iSrcPg, /* Source database page to backup */ |
229 | const u8 *zSrcData, /* Source database page data */ |
230 | int bUpdate /* True for an update, false otherwise */ |
231 | ){ |
232 | Pager * const = sqlite3BtreePager(p->pDest); |
233 | const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc); |
234 | int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest); |
235 | const int nCopy = MIN(nSrcPgsz, nDestPgsz); |
236 | const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz; |
237 | int rc = SQLITE_OK; |
238 | i64 iOff; |
239 | |
240 | assert( sqlite3BtreeGetReserveNoMutex(p->pSrc)>=0 ); |
241 | assert( p->bDestLocked ); |
242 | assert( !isFatalError(p->rc) ); |
243 | assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ); |
244 | assert( zSrcData ); |
245 | |
246 | /* Catch the case where the destination is an in-memory database and the |
247 | ** page sizes of the source and destination differ. |
248 | */ |
249 | if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){ |
250 | rc = SQLITE_READONLY; |
251 | } |
252 | |
253 | /* This loop runs once for each destination page spanned by the source |
254 | ** page. For each iteration, variable iOff is set to the byte offset |
255 | ** of the destination page. |
256 | */ |
257 | for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){ |
258 | DbPage *pDestPg = 0; |
259 | Pgno iDest = (Pgno)(iOff/nDestPgsz)+1; |
260 | if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue; |
261 | if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg, 0)) |
262 | && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg)) |
263 | ){ |
264 | const u8 *zIn = &zSrcData[iOff%nSrcPgsz]; |
265 | u8 *zDestData = sqlite3PagerGetData(pDestPg); |
266 | u8 *zOut = &zDestData[iOff%nDestPgsz]; |
267 | |
268 | /* Copy the data from the source page into the destination page. |
269 | ** Then clear the Btree layer MemPage.isInit flag. Both this module |
270 | ** and the pager code use this trick (clearing the first byte |
271 | ** of the page 'extra' space to invalidate the Btree layers |
272 | ** cached parse of the page). MemPage.isInit is marked |
273 | ** "MUST BE FIRST" for this purpose. |
274 | */ |
275 | memcpy(zOut, zIn, nCopy); |
276 | ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0; |
277 | if( iOff==0 && bUpdate==0 ){ |
278 | sqlite3Put4byte(&zOut[28], sqlite3BtreeLastPage(p->pSrc)); |
279 | } |
280 | } |
281 | sqlite3PagerUnref(pDestPg); |
282 | } |
283 | |
284 | return rc; |
285 | } |
286 | |
287 | /* |
288 | ** If pFile is currently larger than iSize bytes, then truncate it to |
289 | ** exactly iSize bytes. If pFile is not larger than iSize bytes, then |
290 | ** this function is a no-op. |
291 | ** |
292 | ** Return SQLITE_OK if everything is successful, or an SQLite error |
293 | ** code if an error occurs. |
294 | */ |
295 | static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){ |
296 | i64 iCurrent; |
297 | int rc = sqlite3OsFileSize(pFile, &iCurrent); |
298 | if( rc==SQLITE_OK && iCurrent>iSize ){ |
299 | rc = sqlite3OsTruncate(pFile, iSize); |
300 | } |
301 | return rc; |
302 | } |
303 | |
304 | /* |
305 | ** Register this backup object with the associated source pager for |
306 | ** callbacks when pages are changed or the cache invalidated. |
307 | */ |
308 | static void attachBackupObject(sqlite3_backup *p){ |
309 | sqlite3_backup **pp; |
310 | assert( sqlite3BtreeHoldsMutex(p->pSrc) ); |
311 | pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); |
312 | p->pNext = *pp; |
313 | *pp = p; |
314 | p->isAttached = 1; |
315 | } |
316 | |
317 | /* |
318 | ** Copy nPage pages from the source b-tree to the destination. |
319 | */ |
320 | int sqlite3_backup_step(sqlite3_backup *p, int nPage){ |
321 | int rc; |
322 | int destMode; /* Destination journal mode */ |
323 | int pgszSrc = 0; /* Source page size */ |
324 | int pgszDest = 0; /* Destination page size */ |
325 | |
326 | #ifdef SQLITE_ENABLE_API_ARMOR |
327 | if( p==0 ) return SQLITE_MISUSE_BKPT; |
328 | #endif |
329 | sqlite3_mutex_enter(p->pSrcDb->mutex); |
330 | sqlite3BtreeEnter(p->pSrc); |
331 | if( p->pDestDb ){ |
332 | sqlite3_mutex_enter(p->pDestDb->mutex); |
333 | } |
334 | |
335 | rc = p->rc; |
336 | if( !isFatalError(rc) ){ |
337 | Pager * const = sqlite3BtreePager(p->pSrc); /* Source pager */ |
338 | Pager * const = sqlite3BtreePager(p->pDest); /* Dest pager */ |
339 | int ii; /* Iterator variable */ |
340 | int nSrcPage = -1; /* Size of source db in pages */ |
341 | int bCloseTrans = 0; /* True if src db requires unlocking */ |
342 | |
343 | /* If the source pager is currently in a write-transaction, return |
344 | ** SQLITE_BUSY immediately. |
345 | */ |
346 | if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){ |
347 | rc = SQLITE_BUSY; |
348 | }else{ |
349 | rc = SQLITE_OK; |
350 | } |
351 | |
352 | /* If there is no open read-transaction on the source database, open |
353 | ** one now. If a transaction is opened here, then it will be closed |
354 | ** before this function exits. |
355 | */ |
356 | if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){ |
357 | rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0); |
358 | bCloseTrans = 1; |
359 | } |
360 | |
361 | /* If the destination database has not yet been locked (i.e. if this |
362 | ** is the first call to backup_step() for the current backup operation), |
363 | ** try to set its page size to the same as the source database. This |
364 | ** is especially important on ZipVFS systems, as in that case it is |
365 | ** not possible to create a database file that uses one page size by |
366 | ** writing to it with another. */ |
367 | if( p->bDestLocked==0 && rc==SQLITE_OK && setDestPgsz(p)==SQLITE_NOMEM ){ |
368 | rc = SQLITE_NOMEM; |
369 | } |
370 | |
371 | /* Lock the destination database, if it is not locked already. */ |
372 | if( SQLITE_OK==rc && p->bDestLocked==0 |
373 | && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2, |
374 | (int*)&p->iDestSchema)) |
375 | ){ |
376 | p->bDestLocked = 1; |
377 | } |
378 | |
379 | /* Do not allow backup if the destination database is in WAL mode |
380 | ** and the page sizes are different between source and destination */ |
381 | pgszSrc = sqlite3BtreeGetPageSize(p->pSrc); |
382 | pgszDest = sqlite3BtreeGetPageSize(p->pDest); |
383 | destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest)); |
384 | if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){ |
385 | rc = SQLITE_READONLY; |
386 | } |
387 | |
388 | /* Now that there is a read-lock on the source database, query the |
389 | ** source pager for the number of pages in the database. |
390 | */ |
391 | nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc); |
392 | assert( nSrcPage>=0 ); |
393 | for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){ |
394 | const Pgno iSrcPg = p->iNext; /* Source page number */ |
395 | if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){ |
396 | DbPage *pSrcPg; /* Source page object */ |
397 | rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg,PAGER_GET_READONLY); |
398 | if( rc==SQLITE_OK ){ |
399 | rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg), 0); |
400 | sqlite3PagerUnref(pSrcPg); |
401 | } |
402 | } |
403 | p->iNext++; |
404 | } |
405 | if( rc==SQLITE_OK ){ |
406 | p->nPagecount = nSrcPage; |
407 | p->nRemaining = nSrcPage+1-p->iNext; |
408 | if( p->iNext>(Pgno)nSrcPage ){ |
409 | rc = SQLITE_DONE; |
410 | }else if( !p->isAttached ){ |
411 | attachBackupObject(p); |
412 | } |
413 | } |
414 | |
415 | /* Update the schema version field in the destination database. This |
416 | ** is to make sure that the schema-version really does change in |
417 | ** the case where the source and destination databases have the |
418 | ** same schema version. |
419 | */ |
420 | if( rc==SQLITE_DONE ){ |
421 | if( nSrcPage==0 ){ |
422 | rc = sqlite3BtreeNewDb(p->pDest); |
423 | nSrcPage = 1; |
424 | } |
425 | if( rc==SQLITE_OK || rc==SQLITE_DONE ){ |
426 | rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1); |
427 | } |
428 | if( rc==SQLITE_OK ){ |
429 | if( p->pDestDb ){ |
430 | sqlite3ResetAllSchemasOfConnection(p->pDestDb); |
431 | } |
432 | if( destMode==PAGER_JOURNALMODE_WAL ){ |
433 | rc = sqlite3BtreeSetVersion(p->pDest, 2); |
434 | } |
435 | } |
436 | if( rc==SQLITE_OK ){ |
437 | int nDestTruncate; |
438 | /* Set nDestTruncate to the final number of pages in the destination |
439 | ** database. The complication here is that the destination page |
440 | ** size may be different to the source page size. |
441 | ** |
442 | ** If the source page size is smaller than the destination page size, |
443 | ** round up. In this case the call to sqlite3OsTruncate() below will |
444 | ** fix the size of the file. However it is important to call |
445 | ** sqlite3PagerTruncateImage() here so that any pages in the |
446 | ** destination file that lie beyond the nDestTruncate page mark are |
447 | ** journalled by PagerCommitPhaseOne() before they are destroyed |
448 | ** by the file truncation. |
449 | */ |
450 | assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) ); |
451 | assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) ); |
452 | if( pgszSrc<pgszDest ){ |
453 | int ratio = pgszDest/pgszSrc; |
454 | nDestTruncate = (nSrcPage+ratio-1)/ratio; |
455 | if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){ |
456 | nDestTruncate--; |
457 | } |
458 | }else{ |
459 | nDestTruncate = nSrcPage * (pgszSrc/pgszDest); |
460 | } |
461 | assert( nDestTruncate>0 ); |
462 | |
463 | if( pgszSrc<pgszDest ){ |
464 | /* If the source page-size is smaller than the destination page-size, |
465 | ** two extra things may need to happen: |
466 | ** |
467 | ** * The destination may need to be truncated, and |
468 | ** |
469 | ** * Data stored on the pages immediately following the |
470 | ** pending-byte page in the source database may need to be |
471 | ** copied into the destination database. |
472 | */ |
473 | const i64 iSize = (i64)pgszSrc * (i64)nSrcPage; |
474 | sqlite3_file * const pFile = sqlite3PagerFile(pDestPager); |
475 | Pgno iPg; |
476 | int nDstPage; |
477 | i64 iOff; |
478 | i64 iEnd; |
479 | |
480 | assert( pFile ); |
481 | assert( nDestTruncate==0 |
482 | || (i64)nDestTruncate*(i64)pgszDest >= iSize || ( |
483 | nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1) |
484 | && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest |
485 | )); |
486 | |
487 | /* This block ensures that all data required to recreate the original |
488 | ** database has been stored in the journal for pDestPager and the |
489 | ** journal synced to disk. So at this point we may safely modify |
490 | ** the database file in any way, knowing that if a power failure |
491 | ** occurs, the original database will be reconstructed from the |
492 | ** journal file. */ |
493 | sqlite3PagerPagecount(pDestPager, &nDstPage); |
494 | for(iPg=nDestTruncate; rc==SQLITE_OK && iPg<=(Pgno)nDstPage; iPg++){ |
495 | if( iPg!=PENDING_BYTE_PAGE(p->pDest->pBt) ){ |
496 | DbPage *pPg; |
497 | rc = sqlite3PagerGet(pDestPager, iPg, &pPg, 0); |
498 | if( rc==SQLITE_OK ){ |
499 | rc = sqlite3PagerWrite(pPg); |
500 | sqlite3PagerUnref(pPg); |
501 | } |
502 | } |
503 | } |
504 | if( rc==SQLITE_OK ){ |
505 | rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1); |
506 | } |
507 | |
508 | /* Write the extra pages and truncate the database file as required */ |
509 | iEnd = MIN(PENDING_BYTE + pgszDest, iSize); |
510 | for( |
511 | iOff=PENDING_BYTE+pgszSrc; |
512 | rc==SQLITE_OK && iOff<iEnd; |
513 | iOff+=pgszSrc |
514 | ){ |
515 | PgHdr *pSrcPg = 0; |
516 | const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1); |
517 | rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg, 0); |
518 | if( rc==SQLITE_OK ){ |
519 | u8 *zData = sqlite3PagerGetData(pSrcPg); |
520 | rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff); |
521 | } |
522 | sqlite3PagerUnref(pSrcPg); |
523 | } |
524 | if( rc==SQLITE_OK ){ |
525 | rc = backupTruncateFile(pFile, iSize); |
526 | } |
527 | |
528 | /* Sync the database file to disk. */ |
529 | if( rc==SQLITE_OK ){ |
530 | rc = sqlite3PagerSync(pDestPager, 0); |
531 | } |
532 | }else{ |
533 | sqlite3PagerTruncateImage(pDestPager, nDestTruncate); |
534 | rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0); |
535 | } |
536 | |
537 | /* Finish committing the transaction to the destination database. */ |
538 | if( SQLITE_OK==rc |
539 | && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0)) |
540 | ){ |
541 | rc = SQLITE_DONE; |
542 | } |
543 | } |
544 | } |
545 | |
546 | /* If bCloseTrans is true, then this function opened a read transaction |
547 | ** on the source database. Close the read transaction here. There is |
548 | ** no need to check the return values of the btree methods here, as |
549 | ** "committing" a read-only transaction cannot fail. |
550 | */ |
551 | if( bCloseTrans ){ |
552 | TESTONLY( int rc2 ); |
553 | TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0); |
554 | TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0); |
555 | assert( rc2==SQLITE_OK ); |
556 | } |
557 | |
558 | if( rc==SQLITE_IOERR_NOMEM ){ |
559 | rc = SQLITE_NOMEM_BKPT; |
560 | } |
561 | p->rc = rc; |
562 | } |
563 | if( p->pDestDb ){ |
564 | sqlite3_mutex_leave(p->pDestDb->mutex); |
565 | } |
566 | sqlite3BtreeLeave(p->pSrc); |
567 | sqlite3_mutex_leave(p->pSrcDb->mutex); |
568 | return rc; |
569 | } |
570 | |
571 | /* |
572 | ** Release all resources associated with an sqlite3_backup* handle. |
573 | */ |
574 | int sqlite3_backup_finish(sqlite3_backup *p){ |
575 | sqlite3_backup **pp; /* Ptr to head of pagers backup list */ |
576 | sqlite3 *pSrcDb; /* Source database connection */ |
577 | int rc; /* Value to return */ |
578 | |
579 | /* Enter the mutexes */ |
580 | if( p==0 ) return SQLITE_OK; |
581 | pSrcDb = p->pSrcDb; |
582 | sqlite3_mutex_enter(pSrcDb->mutex); |
583 | sqlite3BtreeEnter(p->pSrc); |
584 | if( p->pDestDb ){ |
585 | sqlite3_mutex_enter(p->pDestDb->mutex); |
586 | } |
587 | |
588 | /* Detach this backup from the source pager. */ |
589 | if( p->pDestDb ){ |
590 | p->pSrc->nBackup--; |
591 | } |
592 | if( p->isAttached ){ |
593 | pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc)); |
594 | assert( pp!=0 ); |
595 | while( *pp!=p ){ |
596 | pp = &(*pp)->pNext; |
597 | assert( pp!=0 ); |
598 | } |
599 | *pp = p->pNext; |
600 | } |
601 | |
602 | /* If a transaction is still open on the Btree, roll it back. */ |
603 | sqlite3BtreeRollback(p->pDest, SQLITE_OK, 0); |
604 | |
605 | /* Set the error code of the destination database handle. */ |
606 | rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc; |
607 | if( p->pDestDb ){ |
608 | sqlite3Error(p->pDestDb, rc); |
609 | |
610 | /* Exit the mutexes and free the backup context structure. */ |
611 | sqlite3LeaveMutexAndCloseZombie(p->pDestDb); |
612 | } |
613 | sqlite3BtreeLeave(p->pSrc); |
614 | if( p->pDestDb ){ |
615 | /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a |
616 | ** call to sqlite3_backup_init() and is destroyed by a call to |
617 | ** sqlite3_backup_finish(). */ |
618 | sqlite3_free(p); |
619 | } |
620 | sqlite3LeaveMutexAndCloseZombie(pSrcDb); |
621 | return rc; |
622 | } |
623 | |
624 | /* |
625 | ** Return the number of pages still to be backed up as of the most recent |
626 | ** call to sqlite3_backup_step(). |
627 | */ |
628 | int sqlite3_backup_remaining(sqlite3_backup *p){ |
629 | #ifdef SQLITE_ENABLE_API_ARMOR |
630 | if( p==0 ){ |
631 | (void)SQLITE_MISUSE_BKPT; |
632 | return 0; |
633 | } |
634 | #endif |
635 | return p->nRemaining; |
636 | } |
637 | |
638 | /* |
639 | ** Return the total number of pages in the source database as of the most |
640 | ** recent call to sqlite3_backup_step(). |
641 | */ |
642 | int sqlite3_backup_pagecount(sqlite3_backup *p){ |
643 | #ifdef SQLITE_ENABLE_API_ARMOR |
644 | if( p==0 ){ |
645 | (void)SQLITE_MISUSE_BKPT; |
646 | return 0; |
647 | } |
648 | #endif |
649 | return p->nPagecount; |
650 | } |
651 | |
652 | /* |
653 | ** This function is called after the contents of page iPage of the |
654 | ** source database have been modified. If page iPage has already been |
655 | ** copied into the destination database, then the data written to the |
656 | ** destination is now invalidated. The destination copy of iPage needs |
657 | ** to be updated with the new data before the backup operation is |
658 | ** complete. |
659 | ** |
660 | ** It is assumed that the mutex associated with the BtShared object |
661 | ** corresponding to the source database is held when this function is |
662 | ** called. |
663 | */ |
664 | static SQLITE_NOINLINE void backupUpdate( |
665 | sqlite3_backup *p, |
666 | Pgno iPage, |
667 | const u8 *aData |
668 | ){ |
669 | assert( p!=0 ); |
670 | do{ |
671 | assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); |
672 | if( !isFatalError(p->rc) && iPage<p->iNext ){ |
673 | /* The backup process p has already copied page iPage. But now it |
674 | ** has been modified by a transaction on the source pager. Copy |
675 | ** the new data into the backup. |
676 | */ |
677 | int rc; |
678 | assert( p->pDestDb ); |
679 | sqlite3_mutex_enter(p->pDestDb->mutex); |
680 | rc = backupOnePage(p, iPage, aData, 1); |
681 | sqlite3_mutex_leave(p->pDestDb->mutex); |
682 | assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED ); |
683 | if( rc!=SQLITE_OK ){ |
684 | p->rc = rc; |
685 | } |
686 | } |
687 | }while( (p = p->pNext)!=0 ); |
688 | } |
689 | void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){ |
690 | if( pBackup ) backupUpdate(pBackup, iPage, aData); |
691 | } |
692 | |
693 | /* |
694 | ** Restart the backup process. This is called when the pager layer |
695 | ** detects that the database has been modified by an external database |
696 | ** connection. In this case there is no way of knowing which of the |
697 | ** pages that have been copied into the destination database are still |
698 | ** valid and which are not, so the entire process needs to be restarted. |
699 | ** |
700 | ** It is assumed that the mutex associated with the BtShared object |
701 | ** corresponding to the source database is held when this function is |
702 | ** called. |
703 | */ |
704 | void sqlite3BackupRestart(sqlite3_backup *pBackup){ |
705 | sqlite3_backup *p; /* Iterator variable */ |
706 | for(p=pBackup; p; p=p->pNext){ |
707 | assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) ); |
708 | p->iNext = 1; |
709 | } |
710 | } |
711 | |
712 | #ifndef SQLITE_OMIT_VACUUM |
713 | /* |
714 | ** Copy the complete content of pBtFrom into pBtTo. A transaction |
715 | ** must be active for both files. |
716 | ** |
717 | ** The size of file pTo may be reduced by this operation. If anything |
718 | ** goes wrong, the transaction on pTo is rolled back. If successful, the |
719 | ** transaction is committed before returning. |
720 | */ |
721 | int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){ |
722 | int rc; |
723 | sqlite3_file *pFd; /* File descriptor for database pTo */ |
724 | sqlite3_backup b; |
725 | sqlite3BtreeEnter(pTo); |
726 | sqlite3BtreeEnter(pFrom); |
727 | |
728 | assert( sqlite3BtreeTxnState(pTo)==SQLITE_TXN_WRITE ); |
729 | pFd = sqlite3PagerFile(sqlite3BtreePager(pTo)); |
730 | if( pFd->pMethods ){ |
731 | i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom); |
732 | rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte); |
733 | if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; |
734 | if( rc ) goto copy_finished; |
735 | } |
736 | |
737 | /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set |
738 | ** to 0. This is used by the implementations of sqlite3_backup_step() |
739 | ** and sqlite3_backup_finish() to detect that they are being called |
740 | ** from this function, not directly by the user. |
741 | */ |
742 | memset(&b, 0, sizeof(b)); |
743 | b.pSrcDb = pFrom->db; |
744 | b.pSrc = pFrom; |
745 | b.pDest = pTo; |
746 | b.iNext = 1; |
747 | |
748 | /* 0x7FFFFFFF is the hard limit for the number of pages in a database |
749 | ** file. By passing this as the number of pages to copy to |
750 | ** sqlite3_backup_step(), we can guarantee that the copy finishes |
751 | ** within a single call (unless an error occurs). The assert() statement |
752 | ** checks this assumption - (p->rc) should be set to either SQLITE_DONE |
753 | ** or an error code. */ |
754 | sqlite3_backup_step(&b, 0x7FFFFFFF); |
755 | assert( b.rc!=SQLITE_OK ); |
756 | |
757 | rc = sqlite3_backup_finish(&b); |
758 | if( rc==SQLITE_OK ){ |
759 | pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED; |
760 | }else{ |
761 | sqlite3PagerClearCache(sqlite3BtreePager(b.pDest)); |
762 | } |
763 | |
764 | assert( sqlite3BtreeTxnState(pTo)!=SQLITE_TXN_WRITE ); |
765 | copy_finished: |
766 | sqlite3BtreeLeave(pFrom); |
767 | sqlite3BtreeLeave(pTo); |
768 | return rc; |
769 | } |
770 | #endif /* SQLITE_OMIT_VACUUM */ |
771 | |