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 | */ |
25 | typedef struct sqlite3_vfs MemVfs; |
26 | typedef struct MemFile MemFile; |
27 | typedef 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 | */ |
70 | struct 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 */ |
85 | struct 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 | */ |
97 | static 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 | */ |
105 | static int memdbClose(sqlite3_file*); |
106 | static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); |
107 | static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); |
108 | static int memdbTruncate(sqlite3_file*, sqlite3_int64 size); |
109 | static int memdbSync(sqlite3_file*, int flags); |
110 | static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize); |
111 | static int memdbLock(sqlite3_file*, int); |
112 | static int memdbUnlock(sqlite3_file*, int); |
113 | /* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */ |
114 | static int memdbFileControl(sqlite3_file*, int op, void *pArg); |
115 | /* static int memdbSectorSize(sqlite3_file*); // not used */ |
116 | static int memdbDeviceCharacteristics(sqlite3_file*); |
117 | static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); |
118 | static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); |
119 | |
120 | /* |
121 | ** Methods for MemVfs |
122 | */ |
123 | static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); |
124 | /* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */ |
125 | static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *); |
126 | static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); |
127 | static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename); |
128 | static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg); |
129 | static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); |
130 | static void memdbDlClose(sqlite3_vfs*, void*); |
131 | static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut); |
132 | static int memdbSleep(sqlite3_vfs*, int microseconds); |
133 | /* static int memdbCurrentTime(sqlite3_vfs*, double*); */ |
134 | static int memdbGetLastError(sqlite3_vfs*, int, char *); |
135 | static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); |
136 | |
137 | static 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 | |
162 | static 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 |
188 | static void memdbEnter(MemStore *p){ |
189 | UNUSED_PARAMETER(p); |
190 | } |
191 | static void memdbLeave(MemStore *p){ |
192 | UNUSED_PARAMETER(p); |
193 | } |
194 | #else |
195 | static void memdbEnter(MemStore *p){ |
196 | sqlite3_mutex_enter(p->pMutex); |
197 | } |
198 | static 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 | */ |
210 | static 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 | */ |
252 | static 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 | */ |
274 | static 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 | */ |
294 | static 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 | */ |
331 | static 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 | */ |
348 | static 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 | */ |
357 | static 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 | */ |
368 | static 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 | */ |
426 | static 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 | */ |
454 | static 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 | */ |
464 | static 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 | */ |
493 | static 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 | */ |
501 | static 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 */ |
510 | static 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 */ |
529 | static 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 | */ |
542 | static 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 | */ |
628 | static 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 | */ |
639 | static 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 | */ |
657 | static 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 | */ |
671 | static 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 | */ |
680 | static 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 | */ |
687 | static 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 | */ |
694 | static 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 | */ |
702 | static 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 | */ |
710 | static 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 | */ |
718 | static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ |
719 | return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); |
720 | } |
721 | #endif |
722 | |
723 | static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){ |
724 | return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); |
725 | } |
726 | static 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 | */ |
734 | static 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 | */ |
750 | unsigned 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 * = 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 | */ |
831 | int 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 | |
894 | end_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 | */ |
906 | int 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 | */ |
914 | int 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 | |