1/*
2** 2016-09-07
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 an in-memory VFS. A database is held as a contiguous
14** block of memory.
15**
16** This file also implements interface sqlite3_serialize() and
17** sqlite3_deserialize().
18*/
19#include "sqliteInt.h"
20#ifndef SQLITE_OMIT_DESERIALIZE
21
22/*
23** Forward declaration of objects used by this utility
24*/
25typedef struct sqlite3_vfs MemVfs;
26typedef struct MemFile MemFile;
27typedef struct MemStore MemStore;
28
29/* Access to a lower-level VFS that (might) implement dynamic loading,
30** access to randomness, etc.
31*/
32#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
33
34/* Storage for a memdb file.
35**
36** An memdb object can be shared or separate. Shared memdb objects can be
37** used by more than one database connection. Mutexes are used by shared
38** memdb objects to coordinate access. Separate memdb objects are only
39** connected to a single database connection and do not require additional
40** mutexes.
41**
42** Shared memdb objects have .zFName!=0 and .pMutex!=0. They are created
43** using "file:/name?vfs=memdb". The first character of the name must be
44** "/" or else the object will be a separate memdb object. All shared
45** memdb objects are stored in memdb_g.apMemStore[] in an arbitrary order.
46**
47** Separate memdb objects are created using a name that does not begin
48** with "/" or using sqlite3_deserialize().
49**
50** Access rules for shared MemStore objects:
51**
52** * .zFName is initialized when the object is created and afterwards
53** is unchanged until the object is destroyed. So it can be accessed
54** at any time as long as we know the object is not being destroyed,
55** which means while either the SQLITE_MUTEX_STATIC_VFS1 or
56** .pMutex is held or the object is not part of memdb_g.apMemStore[].
57**
58** * Can .pMutex can only be changed while holding the
59** SQLITE_MUTEX_STATIC_VFS1 mutex or while the object is not part
60** of memdb_g.apMemStore[].
61**
62** * Other fields can only be changed while holding the .pMutex mutex
63** or when the .nRef is less than zero and the object is not part of
64** memdb_g.apMemStore[].
65**
66** * The .aData pointer has the added requirement that it can can only
67** be changed (for resizing) when nMmap is zero.
68**
69*/
70struct MemStore {
71 sqlite3_int64 sz; /* Size of the file */
72 sqlite3_int64 szAlloc; /* Space allocated to aData */
73 sqlite3_int64 szMax; /* Maximum allowed size of the file */
74 unsigned char *aData; /* content of the file */
75 sqlite3_mutex *pMutex; /* Used by shared stores only */
76 int nMmap; /* Number of memory mapped pages */
77 unsigned mFlags; /* Flags */
78 int nRdLock; /* Number of readers */
79 int nWrLock; /* Number of writers. (Always 0 or 1) */
80 int nRef; /* Number of users of this MemStore */
81 char *zFName; /* The filename for shared stores */
82};
83
84/* An open file */
85struct MemFile {
86 sqlite3_file base; /* IO methods */
87 MemStore *pStore; /* The storage */
88 int eLock; /* Most recent lock against this file */
89};
90
91/*
92** File-scope variables for holding the memdb files that are accessible
93** to multiple database connections in separate threads.
94**
95** Must hold SQLITE_MUTEX_STATIC_VFS1 to access any part of this object.
96*/
97static struct MemFS {
98 int nMemStore; /* Number of shared MemStore objects */
99 MemStore **apMemStore; /* Array of all shared MemStore objects */
100} memdb_g;
101
102/*
103** Methods for MemFile
104*/
105static int memdbClose(sqlite3_file*);
106static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
107static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
108static int memdbTruncate(sqlite3_file*, sqlite3_int64 size);
109static int memdbSync(sqlite3_file*, int flags);
110static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize);
111static int memdbLock(sqlite3_file*, int);
112static int memdbUnlock(sqlite3_file*, int);
113/* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */
114static int memdbFileControl(sqlite3_file*, int op, void *pArg);
115/* static int memdbSectorSize(sqlite3_file*); // not used */
116static int memdbDeviceCharacteristics(sqlite3_file*);
117static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
118static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p);
119
120/*
121** Methods for MemVfs
122*/
123static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
124/* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */
125static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
126static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
127static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename);
128static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
129static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
130static void memdbDlClose(sqlite3_vfs*, void*);
131static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut);
132static int memdbSleep(sqlite3_vfs*, int microseconds);
133/* static int memdbCurrentTime(sqlite3_vfs*, double*); */
134static int memdbGetLastError(sqlite3_vfs*, int, char *);
135static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
136
137static sqlite3_vfs memdb_vfs = {
138 2, /* iVersion */
139 0, /* szOsFile (set when registered) */
140 1024, /* mxPathname */
141 0, /* pNext */
142 "memdb", /* zName */
143 0, /* pAppData (set when registered) */
144 memdbOpen, /* xOpen */
145 0, /* memdbDelete, */ /* xDelete */
146 memdbAccess, /* xAccess */
147 memdbFullPathname, /* xFullPathname */
148 memdbDlOpen, /* xDlOpen */
149 memdbDlError, /* xDlError */
150 memdbDlSym, /* xDlSym */
151 memdbDlClose, /* xDlClose */
152 memdbRandomness, /* xRandomness */
153 memdbSleep, /* xSleep */
154 0, /* memdbCurrentTime, */ /* xCurrentTime */
155 memdbGetLastError, /* xGetLastError */
156 memdbCurrentTimeInt64, /* xCurrentTimeInt64 */
157 0, /* xSetSystemCall */
158 0, /* xGetSystemCall */
159 0, /* xNextSystemCall */
160};
161
162static const sqlite3_io_methods memdb_io_methods = {
163 3, /* iVersion */
164 memdbClose, /* xClose */
165 memdbRead, /* xRead */
166 memdbWrite, /* xWrite */
167 memdbTruncate, /* xTruncate */
168 memdbSync, /* xSync */
169 memdbFileSize, /* xFileSize */
170 memdbLock, /* xLock */
171 memdbUnlock, /* xUnlock */
172 0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */
173 memdbFileControl, /* xFileControl */
174 0, /* memdbSectorSize,*/ /* xSectorSize */
175 memdbDeviceCharacteristics, /* xDeviceCharacteristics */
176 0, /* xShmMap */
177 0, /* xShmLock */
178 0, /* xShmBarrier */
179 0, /* xShmUnmap */
180 memdbFetch, /* xFetch */
181 memdbUnfetch /* xUnfetch */
182};
183
184/*
185** Enter/leave the mutex on a MemStore
186*/
187#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
188static void memdbEnter(MemStore *p){
189 UNUSED_PARAMETER(p);
190}
191static void memdbLeave(MemStore *p){
192 UNUSED_PARAMETER(p);
193}
194#else
195static void memdbEnter(MemStore *p){
196 sqlite3_mutex_enter(p->pMutex);
197}
198static void memdbLeave(MemStore *p){
199 sqlite3_mutex_leave(p->pMutex);
200}
201#endif
202
203
204
205/*
206** Close an memdb-file.
207** Free the underlying MemStore object when its refcount drops to zero
208** or less.
209*/
210static int memdbClose(sqlite3_file *pFile){
211 MemStore *p = ((MemFile*)pFile)->pStore;
212 if( p->zFName ){
213 int i;
214#ifndef SQLITE_MUTEX_OMIT
215 sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
216#endif
217 sqlite3_mutex_enter(pVfsMutex);
218 for(i=0; ALWAYS(i<memdb_g.nMemStore); i++){
219 if( memdb_g.apMemStore[i]==p ){
220 memdbEnter(p);
221 if( p->nRef==1 ){
222 memdb_g.apMemStore[i] = memdb_g.apMemStore[--memdb_g.nMemStore];
223 if( memdb_g.nMemStore==0 ){
224 sqlite3_free(memdb_g.apMemStore);
225 memdb_g.apMemStore = 0;
226 }
227 }
228 break;
229 }
230 }
231 sqlite3_mutex_leave(pVfsMutex);
232 }else{
233 memdbEnter(p);
234 }
235 p->nRef--;
236 if( p->nRef<=0 ){
237 if( p->mFlags & SQLITE_DESERIALIZE_FREEONCLOSE ){
238 sqlite3_free(p->aData);
239 }
240 memdbLeave(p);
241 sqlite3_mutex_free(p->pMutex);
242 sqlite3_free(p);
243 }else{
244 memdbLeave(p);
245 }
246 return SQLITE_OK;
247}
248
249/*
250** Read data from an memdb-file.
251*/
252static int memdbRead(
253 sqlite3_file *pFile,
254 void *zBuf,
255 int iAmt,
256 sqlite_int64 iOfst
257){
258 MemStore *p = ((MemFile*)pFile)->pStore;
259 memdbEnter(p);
260 if( iOfst+iAmt>p->sz ){
261 memset(zBuf, 0, iAmt);
262 if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
263 memdbLeave(p);
264 return SQLITE_IOERR_SHORT_READ;
265 }
266 memcpy(zBuf, p->aData+iOfst, iAmt);
267 memdbLeave(p);
268 return SQLITE_OK;
269}
270
271/*
272** Try to enlarge the memory allocation to hold at least sz bytes
273*/
274static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){
275 unsigned char *pNew;
276 if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){
277 return SQLITE_FULL;
278 }
279 if( newSz>p->szMax ){
280 return SQLITE_FULL;
281 }
282 newSz *= 2;
283 if( newSz>p->szMax ) newSz = p->szMax;
284 pNew = sqlite3Realloc(p->aData, newSz);
285 if( pNew==0 ) return SQLITE_IOERR_NOMEM;
286 p->aData = pNew;
287 p->szAlloc = newSz;
288 return SQLITE_OK;
289}
290
291/*
292** Write data to an memdb-file.
293*/
294static int memdbWrite(
295 sqlite3_file *pFile,
296 const void *z,
297 int iAmt,
298 sqlite_int64 iOfst
299){
300 MemStore *p = ((MemFile*)pFile)->pStore;
301 memdbEnter(p);
302 if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
303 /* Can't happen: memdbLock() will return SQLITE_READONLY before
304 ** reaching this point */
305 memdbLeave(p);
306 return SQLITE_IOERR_WRITE;
307 }
308 if( iOfst+iAmt>p->sz ){
309 int rc;
310 if( iOfst+iAmt>p->szAlloc
311 && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
312 ){
313 memdbLeave(p);
314 return rc;
315 }
316 if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
317 p->sz = iOfst+iAmt;
318 }
319 memcpy(p->aData+iOfst, z, iAmt);
320 memdbLeave(p);
321 return SQLITE_OK;
322}
323
324/*
325** Truncate an memdb-file.
326**
327** In rollback mode (which is always the case for memdb, as it does not
328** support WAL mode) the truncate() method is only used to reduce
329** the size of a file, never to increase the size.
330*/
331static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
332 MemStore *p = ((MemFile*)pFile)->pStore;
333 int rc = SQLITE_OK;
334 memdbEnter(p);
335 if( size>p->sz ){
336 /* This can only happen with a corrupt wal mode db */
337 rc = SQLITE_CORRUPT;
338 }else{
339 p->sz = size;
340 }
341 memdbLeave(p);
342 return rc;
343}
344
345/*
346** Sync an memdb-file.
347*/
348static int memdbSync(sqlite3_file *pFile, int flags){
349 UNUSED_PARAMETER(pFile);
350 UNUSED_PARAMETER(flags);
351 return SQLITE_OK;
352}
353
354/*
355** Return the current file-size of an memdb-file.
356*/
357static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
358 MemStore *p = ((MemFile*)pFile)->pStore;
359 memdbEnter(p);
360 *pSize = p->sz;
361 memdbLeave(p);
362 return SQLITE_OK;
363}
364
365/*
366** Lock an memdb-file.
367*/
368static int memdbLock(sqlite3_file *pFile, int eLock){
369 MemFile *pThis = (MemFile*)pFile;
370 MemStore *p = pThis->pStore;
371 int rc = SQLITE_OK;
372 if( eLock<=pThis->eLock ) return SQLITE_OK;
373 memdbEnter(p);
374
375 assert( p->nWrLock==0 || p->nWrLock==1 );
376 assert( pThis->eLock<=SQLITE_LOCK_SHARED || p->nWrLock==1 );
377 assert( pThis->eLock==SQLITE_LOCK_NONE || p->nRdLock>=1 );
378
379 if( eLock>SQLITE_LOCK_SHARED && (p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
380 rc = SQLITE_READONLY;
381 }else{
382 switch( eLock ){
383 case SQLITE_LOCK_SHARED: {
384 assert( pThis->eLock==SQLITE_LOCK_NONE );
385 if( p->nWrLock>0 ){
386 rc = SQLITE_BUSY;
387 }else{
388 p->nRdLock++;
389 }
390 break;
391 };
392
393 case SQLITE_LOCK_RESERVED:
394 case SQLITE_LOCK_PENDING: {
395 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
396 if( ALWAYS(pThis->eLock==SQLITE_LOCK_SHARED) ){
397 if( p->nWrLock>0 ){
398 rc = SQLITE_BUSY;
399 }else{
400 p->nWrLock = 1;
401 }
402 }
403 break;
404 }
405
406 default: {
407 assert( eLock==SQLITE_LOCK_EXCLUSIVE );
408 assert( pThis->eLock>=SQLITE_LOCK_SHARED );
409 if( p->nRdLock>1 ){
410 rc = SQLITE_BUSY;
411 }else if( pThis->eLock==SQLITE_LOCK_SHARED ){
412 p->nWrLock = 1;
413 }
414 break;
415 }
416 }
417 }
418 if( rc==SQLITE_OK ) pThis->eLock = eLock;
419 memdbLeave(p);
420 return rc;
421}
422
423/*
424** Unlock an memdb-file.
425*/
426static int memdbUnlock(sqlite3_file *pFile, int eLock){
427 MemFile *pThis = (MemFile*)pFile;
428 MemStore *p = pThis->pStore;
429 if( eLock>=pThis->eLock ) return SQLITE_OK;
430 memdbEnter(p);
431
432 assert( eLock==SQLITE_LOCK_SHARED || eLock==SQLITE_LOCK_NONE );
433 if( eLock==SQLITE_LOCK_SHARED ){
434 if( ALWAYS(pThis->eLock>SQLITE_LOCK_SHARED) ){
435 p->nWrLock--;
436 }
437 }else{
438 if( pThis->eLock>SQLITE_LOCK_SHARED ){
439 p->nWrLock--;
440 }
441 p->nRdLock--;
442 }
443
444 pThis->eLock = eLock;
445 memdbLeave(p);
446 return SQLITE_OK;
447}
448
449#if 0
450/*
451** This interface is only used for crash recovery, which does not
452** occur on an in-memory database.
453*/
454static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
455 *pResOut = 0;
456 return SQLITE_OK;
457}
458#endif
459
460
461/*
462** File control method. For custom operations on an memdb-file.
463*/
464static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
465 MemStore *p = ((MemFile*)pFile)->pStore;
466 int rc = SQLITE_NOTFOUND;
467 memdbEnter(p);
468 if( op==SQLITE_FCNTL_VFSNAME ){
469 *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
470 rc = SQLITE_OK;
471 }
472 if( op==SQLITE_FCNTL_SIZE_LIMIT ){
473 sqlite3_int64 iLimit = *(sqlite3_int64*)pArg;
474 if( iLimit<p->sz ){
475 if( iLimit<0 ){
476 iLimit = p->szMax;
477 }else{
478 iLimit = p->sz;
479 }
480 }
481 p->szMax = iLimit;
482 *(sqlite3_int64*)pArg = iLimit;
483 rc = SQLITE_OK;
484 }
485 memdbLeave(p);
486 return rc;
487}
488
489#if 0 /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */
490/*
491** Return the sector-size in bytes for an memdb-file.
492*/
493static int memdbSectorSize(sqlite3_file *pFile){
494 return 1024;
495}
496#endif
497
498/*
499** Return the device characteristic flags supported by an memdb-file.
500*/
501static int memdbDeviceCharacteristics(sqlite3_file *pFile){
502 UNUSED_PARAMETER(pFile);
503 return SQLITE_IOCAP_ATOMIC |
504 SQLITE_IOCAP_POWERSAFE_OVERWRITE |
505 SQLITE_IOCAP_SAFE_APPEND |
506 SQLITE_IOCAP_SEQUENTIAL;
507}
508
509/* Fetch a page of a memory-mapped file */
510static int memdbFetch(
511 sqlite3_file *pFile,
512 sqlite3_int64 iOfst,
513 int iAmt,
514 void **pp
515){
516 MemStore *p = ((MemFile*)pFile)->pStore;
517 memdbEnter(p);
518 if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){
519 *pp = 0;
520 }else{
521 p->nMmap++;
522 *pp = (void*)(p->aData + iOfst);
523 }
524 memdbLeave(p);
525 return SQLITE_OK;
526}
527
528/* Release a memory-mapped page */
529static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
530 MemStore *p = ((MemFile*)pFile)->pStore;
531 UNUSED_PARAMETER(iOfst);
532 UNUSED_PARAMETER(pPage);
533 memdbEnter(p);
534 p->nMmap--;
535 memdbLeave(p);
536 return SQLITE_OK;
537}
538
539/*
540** Open an mem file handle.
541*/
542static int memdbOpen(
543 sqlite3_vfs *pVfs,
544 const char *zName,
545 sqlite3_file *pFd,
546 int flags,
547 int *pOutFlags
548){
549 MemFile *pFile = (MemFile*)pFd;
550 MemStore *p = 0;
551 int szName;
552 UNUSED_PARAMETER(pVfs);
553
554 memset(pFile, 0, sizeof(*pFile));
555 szName = sqlite3Strlen30(zName);
556 if( szName>1 && (zName[0]=='/' || zName[0]=='\\') ){
557 int i;
558#ifndef SQLITE_MUTEX_OMIT
559 sqlite3_mutex *pVfsMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
560#endif
561 sqlite3_mutex_enter(pVfsMutex);
562 for(i=0; i<memdb_g.nMemStore; i++){
563 if( strcmp(memdb_g.apMemStore[i]->zFName,zName)==0 ){
564 p = memdb_g.apMemStore[i];
565 break;
566 }
567 }
568 if( p==0 ){
569 MemStore **apNew;
570 p = sqlite3Malloc( sizeof(*p) + szName + 3 );
571 if( p==0 ){
572 sqlite3_mutex_leave(pVfsMutex);
573 return SQLITE_NOMEM;
574 }
575 apNew = sqlite3Realloc(memdb_g.apMemStore,
576 sizeof(apNew[0])*(memdb_g.nMemStore+1) );
577 if( apNew==0 ){
578 sqlite3_free(p);
579 sqlite3_mutex_leave(pVfsMutex);
580 return SQLITE_NOMEM;
581 }
582 apNew[memdb_g.nMemStore++] = p;
583 memdb_g.apMemStore = apNew;
584 memset(p, 0, sizeof(*p));
585 p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE|SQLITE_DESERIALIZE_FREEONCLOSE;
586 p->szMax = sqlite3GlobalConfig.mxMemdbSize;
587 p->zFName = (char*)&p[1];
588 memcpy(p->zFName, zName, szName+1);
589 p->pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
590 if( p->pMutex==0 ){
591 memdb_g.nMemStore--;
592 sqlite3_free(p);
593 sqlite3_mutex_leave(pVfsMutex);
594 return SQLITE_NOMEM;
595 }
596 p->nRef = 1;
597 memdbEnter(p);
598 }else{
599 memdbEnter(p);
600 p->nRef++;
601 }
602 sqlite3_mutex_leave(pVfsMutex);
603 }else{
604 p = sqlite3Malloc( sizeof(*p) );
605 if( p==0 ){
606 return SQLITE_NOMEM;
607 }
608 memset(p, 0, sizeof(*p));
609 p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
610 p->szMax = sqlite3GlobalConfig.mxMemdbSize;
611 }
612 pFile->pStore = p;
613 if( pOutFlags!=0 ){
614 *pOutFlags = flags | SQLITE_OPEN_MEMORY;
615 }
616 pFd->pMethods = &memdb_io_methods;
617 memdbLeave(p);
618 return SQLITE_OK;
619}
620
621#if 0 /* Only used to delete rollback journals, super-journals, and WAL
622 ** files, none of which exist in memdb. So this routine is never used */
623/*
624** Delete the file located at zPath. If the dirSync argument is true,
625** ensure the file-system modifications are synced to disk before
626** returning.
627*/
628static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
629 return SQLITE_IOERR_DELETE;
630}
631#endif
632
633/*
634** Test for access permissions. Return true if the requested permission
635** is available, or false otherwise.
636**
637** With memdb, no files ever exist on disk. So always return false.
638*/
639static int memdbAccess(
640 sqlite3_vfs *pVfs,
641 const char *zPath,
642 int flags,
643 int *pResOut
644){
645 UNUSED_PARAMETER(pVfs);
646 UNUSED_PARAMETER(zPath);
647 UNUSED_PARAMETER(flags);
648 *pResOut = 0;
649 return SQLITE_OK;
650}
651
652/*
653** Populate buffer zOut with the full canonical pathname corresponding
654** to the pathname in zPath. zOut is guaranteed to point to a buffer
655** of at least (INST_MAX_PATHNAME+1) bytes.
656*/
657static int memdbFullPathname(
658 sqlite3_vfs *pVfs,
659 const char *zPath,
660 int nOut,
661 char *zOut
662){
663 UNUSED_PARAMETER(pVfs);
664 sqlite3_snprintf(nOut, zOut, "%s", zPath);
665 return SQLITE_OK;
666}
667
668/*
669** Open the dynamic library located at zPath and return a handle.
670*/
671static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){
672 return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
673}
674
675/*
676** Populate the buffer zErrMsg (size nByte bytes) with a human readable
677** utf-8 string describing the most recent error encountered associated
678** with dynamic libraries.
679*/
680static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
681 ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
682}
683
684/*
685** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
686*/
687static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
688 return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
689}
690
691/*
692** Close the dynamic library handle pHandle.
693*/
694static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){
695 ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
696}
697
698/*
699** Populate the buffer pointed to by zBufOut with nByte bytes of
700** random data.
701*/
702static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
703 return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
704}
705
706/*
707** Sleep for nMicro microseconds. Return the number of microseconds
708** actually slept.
709*/
710static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){
711 return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
712}
713
714#if 0 /* Never used. Modern cores only call xCurrentTimeInt64() */
715/*
716** Return the current time as a Julian Day number in *pTimeOut.
717*/
718static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
719 return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
720}
721#endif
722
723static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){
724 return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
725}
726static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
727 return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
728}
729
730/*
731** Translate a database connection pointer and schema name into a
732** MemFile pointer.
733*/
734static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){
735 MemFile *p = 0;
736 MemStore *pStore;
737 int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p);
738 if( rc ) return 0;
739 if( p->base.pMethods!=&memdb_io_methods ) return 0;
740 pStore = p->pStore;
741 memdbEnter(pStore);
742 if( pStore->zFName!=0 ) p = 0;
743 memdbLeave(pStore);
744 return p;
745}
746
747/*
748** Return the serialization of a database
749*/
750unsigned char *sqlite3_serialize(
751 sqlite3 *db, /* The database connection */
752 const char *zSchema, /* Which database within the connection */
753 sqlite3_int64 *piSize, /* Write size here, if not NULL */
754 unsigned int mFlags /* Maybe SQLITE_SERIALIZE_NOCOPY */
755){
756 MemFile *p;
757 int iDb;
758 Btree *pBt;
759 sqlite3_int64 sz;
760 int szPage = 0;
761 sqlite3_stmt *pStmt = 0;
762 unsigned char *pOut;
763 char *zSql;
764 int rc;
765
766#ifdef SQLITE_ENABLE_API_ARMOR
767 if( !sqlite3SafetyCheckOk(db) ){
768 (void)SQLITE_MISUSE_BKPT;
769 return 0;
770 }
771#endif
772
773 if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
774 p = memdbFromDbSchema(db, zSchema);
775 iDb = sqlite3FindDbName(db, zSchema);
776 if( piSize ) *piSize = -1;
777 if( iDb<0 ) return 0;
778 if( p ){
779 MemStore *pStore = p->pStore;
780 assert( pStore->pMutex==0 );
781 if( piSize ) *piSize = pStore->sz;
782 if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
783 pOut = pStore->aData;
784 }else{
785 pOut = sqlite3_malloc64( pStore->sz );
786 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
787 }
788 return pOut;
789 }
790 pBt = db->aDb[iDb].pBt;
791 if( pBt==0 ) return 0;
792 szPage = sqlite3BtreeGetPageSize(pBt);
793 zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema);
794 rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
795 sqlite3_free(zSql);
796 if( rc ) return 0;
797 rc = sqlite3_step(pStmt);
798 if( rc!=SQLITE_ROW ){
799 pOut = 0;
800 }else{
801 sz = sqlite3_column_int64(pStmt, 0)*szPage;
802 if( piSize ) *piSize = sz;
803 if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
804 pOut = 0;
805 }else{
806 pOut = sqlite3_malloc64( sz );
807 if( pOut ){
808 int nPage = sqlite3_column_int(pStmt, 0);
809 Pager *pPager = sqlite3BtreePager(pBt);
810 int pgno;
811 for(pgno=1; pgno<=nPage; pgno++){
812 DbPage *pPage = 0;
813 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
814 rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
815 if( rc==SQLITE_OK ){
816 memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
817 }else{
818 memset(pTo, 0, szPage);
819 }
820 sqlite3PagerUnref(pPage);
821 }
822 }
823 }
824 }
825 sqlite3_finalize(pStmt);
826 return pOut;
827}
828
829/* Convert zSchema to a MemDB and initialize its content.
830*/
831int sqlite3_deserialize(
832 sqlite3 *db, /* The database connection */
833 const char *zSchema, /* Which DB to reopen with the deserialization */
834 unsigned char *pData, /* The serialized database content */
835 sqlite3_int64 szDb, /* Number bytes in the deserialization */
836 sqlite3_int64 szBuf, /* Total size of buffer pData[] */
837 unsigned mFlags /* Zero or more SQLITE_DESERIALIZE_* flags */
838){
839 MemFile *p;
840 char *zSql;
841 sqlite3_stmt *pStmt = 0;
842 int rc;
843 int iDb;
844
845#ifdef SQLITE_ENABLE_API_ARMOR
846 if( !sqlite3SafetyCheckOk(db) ){
847 return SQLITE_MISUSE_BKPT;
848 }
849 if( szDb<0 ) return SQLITE_MISUSE_BKPT;
850 if( szBuf<0 ) return SQLITE_MISUSE_BKPT;
851#endif
852
853 sqlite3_mutex_enter(db->mutex);
854 if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
855 iDb = sqlite3FindDbName(db, zSchema);
856 testcase( iDb==1 );
857 if( iDb<2 && iDb!=0 ){
858 rc = SQLITE_ERROR;
859 goto end_deserialize;
860 }
861 zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema);
862 if( zSql==0 ){
863 rc = SQLITE_NOMEM;
864 }else{
865 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
866 sqlite3_free(zSql);
867 }
868 if( rc ) goto end_deserialize;
869 db->init.iDb = (u8)iDb;
870 db->init.reopenMemdb = 1;
871 rc = sqlite3_step(pStmt);
872 db->init.reopenMemdb = 0;
873 if( rc!=SQLITE_DONE ){
874 rc = SQLITE_ERROR;
875 goto end_deserialize;
876 }
877 p = memdbFromDbSchema(db, zSchema);
878 if( p==0 ){
879 rc = SQLITE_ERROR;
880 }else{
881 MemStore *pStore = p->pStore;
882 pStore->aData = pData;
883 pData = 0;
884 pStore->sz = szDb;
885 pStore->szAlloc = szBuf;
886 pStore->szMax = szBuf;
887 if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
888 pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
889 }
890 pStore->mFlags = mFlags;
891 rc = SQLITE_OK;
892 }
893
894end_deserialize:
895 sqlite3_finalize(pStmt);
896 if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){
897 sqlite3_free(pData);
898 }
899 sqlite3_mutex_leave(db->mutex);
900 return rc;
901}
902
903/*
904** Return true if the VFS is the memvfs.
905*/
906int sqlite3IsMemdb(const sqlite3_vfs *pVfs){
907 return pVfs==&memdb_vfs;
908}
909
910/*
911** This routine is called when the extension is loaded.
912** Register the new VFS.
913*/
914int sqlite3MemdbInit(void){
915 sqlite3_vfs *pLower = sqlite3_vfs_find(0);
916 unsigned int sz;
917 if( NEVER(pLower==0) ) return SQLITE_ERROR;
918 sz = pLower->szOsFile;
919 memdb_vfs.pAppData = pLower;
920 /* The following conditional can only be true when compiled for
921 ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0. We always leave
922 ** it in, to be safe, but it is marked as NO_TEST since there
923 ** is no way to reach it under most builds. */
924 if( sz<sizeof(MemFile) ) sz = sizeof(MemFile); /*NO_TEST*/
925 memdb_vfs.szOsFile = sz;
926 return sqlite3_vfs_register(&memdb_vfs, 0);
927}
928#endif /* SQLITE_OMIT_DESERIALIZE */
929