Annotation of embedaddon/sqlite3/src/test_multiplex.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2010 October 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: **
13: ** This file contains a VFS "shim" - a layer that sits in between the
14: ** pager and the real VFS - that breaks up a very large database file
15: ** into two or more smaller files on disk. This is useful, for example,
16: ** in order to support large, multi-gigabyte databases on older filesystems
17: ** that limit the maximum file size to 2 GiB.
18: **
19: ** USAGE:
20: **
21: ** Compile this source file and link it with your application. Then
22: ** at start-time, invoke the following procedure:
23: **
24: ** int sqlite3_multiplex_initialize(
25: ** const char *zOrigVfsName, // The underlying real VFS
26: ** int makeDefault // True to make multiplex the default VFS
27: ** );
28: **
29: ** The procedure call above will create and register a new VFS shim named
30: ** "multiplex". The multiplex VFS will use the VFS named by zOrigVfsName to
31: ** do the actual disk I/O. (The zOrigVfsName parameter may be NULL, in
32: ** which case the default VFS at the moment sqlite3_multiplex_initialize()
33: ** is called will be used as the underlying real VFS.)
34: **
35: ** If the makeDefault parameter is TRUE then multiplex becomes the new
36: ** default VFS. Otherwise, you can use the multiplex VFS by specifying
37: ** "multiplex" as the 4th parameter to sqlite3_open_v2() or by employing
38: ** URI filenames and adding "vfs=multiplex" as a parameter to the filename
39: ** URI.
40: **
41: ** The multiplex VFS allows databases up to 32 GiB in size. But it splits
42: ** the files up into smaller pieces, so that they will work even on
43: ** filesystems that do not support large files. The default chunk size
44: ** is 2147418112 bytes (which is 64KiB less than 2GiB) but this can be
45: ** changed at compile-time by defining the SQLITE_MULTIPLEX_CHUNK_SIZE
46: ** macro. Use the "chunksize=NNNN" query parameter with a URI filename
47: ** in order to select an alternative chunk size for individual connections
48: ** at run-time.
49: */
50: #include "sqlite3.h"
51: #include <string.h>
52: #include <assert.h>
53: #include <stdlib.h>
54: #include "test_multiplex.h"
55:
56: #ifndef SQLITE_CORE
57: #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
58: #endif
59: #include "sqlite3ext.h"
60:
61: /*
62: ** These should be defined to be the same as the values in
63: ** sqliteInt.h. They are defined seperately here so that
64: ** the multiplex VFS shim can be built as a loadable
65: ** module.
66: */
67: #define UNUSED_PARAMETER(x) (void)(x)
68: #define MAX_PAGE_SIZE 0x10000
69: #define DEFAULT_SECTOR_SIZE 0x1000
70:
71: /*
72: ** For a build without mutexes, no-op the mutex calls.
73: */
74: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
75: #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8)
76: #define sqlite3_mutex_free(X)
77: #define sqlite3_mutex_enter(X)
78: #define sqlite3_mutex_try(X) SQLITE_OK
79: #define sqlite3_mutex_leave(X)
80: #define sqlite3_mutex_held(X) ((void)(X),1)
81: #define sqlite3_mutex_notheld(X) ((void)(X),1)
82: #endif /* SQLITE_THREADSAFE==0 */
83:
84: /* First chunk for rollback journal files */
85: #define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400
86:
87:
88: /************************ Shim Definitions ******************************/
89:
90: #ifndef SQLITE_MULTIPLEX_VFS_NAME
91: # define SQLITE_MULTIPLEX_VFS_NAME "multiplex"
92: #endif
93:
94: /* This is the limit on the chunk size. It may be changed by calling
95: ** the xFileControl() interface. It will be rounded up to a
96: ** multiple of MAX_PAGE_SIZE. We default it here to 2GiB less 64KiB.
97: */
98: #ifndef SQLITE_MULTIPLEX_CHUNK_SIZE
99: # define SQLITE_MULTIPLEX_CHUNK_SIZE 2147418112
100: #endif
101:
102: /* This used to be the default limit on number of chunks, but
103: ** it is no longer enforced. There is currently no limit to the
104: ** number of chunks.
105: **
106: ** May be changed by calling the xFileControl() interface.
107: */
108: #ifndef SQLITE_MULTIPLEX_MAX_CHUNKS
109: # define SQLITE_MULTIPLEX_MAX_CHUNKS 12
110: #endif
111:
112: /************************ Object Definitions ******************************/
113:
114: /* Forward declaration of all object types */
115: typedef struct multiplexGroup multiplexGroup;
116: typedef struct multiplexConn multiplexConn;
117:
118: /*
119: ** A "multiplex group" is a collection of files that collectively
120: ** makeup a single SQLite DB file. This allows the size of the DB
121: ** to exceed the limits imposed by the file system.
122: **
123: ** There is an instance of the following object for each defined multiplex
124: ** group.
125: */
126: struct multiplexGroup {
127: struct multiplexReal { /* For each chunk */
128: sqlite3_file *p; /* Handle for the chunk */
129: char *z; /* Name of this chunk */
130: } *aReal; /* list of all chunks */
131: int nReal; /* Number of chunks */
132: char *zName; /* Base filename of this group */
133: int nName; /* Length of base filename */
134: int flags; /* Flags used for original opening */
135: unsigned int szChunk; /* Chunk size used for this group */
136: unsigned char bEnabled; /* TRUE to use Multiplex VFS for this file */
137: unsigned char bTruncate; /* TRUE to enable truncation of databases */
138: multiplexGroup *pNext, *pPrev; /* Doubly linked list of all group objects */
139: };
140:
141: /*
142: ** An instance of the following object represents each open connection
143: ** to a file that is multiplex'ed. This object is a
144: ** subclass of sqlite3_file. The sqlite3_file object for the underlying
145: ** VFS is appended to this structure.
146: */
147: struct multiplexConn {
148: sqlite3_file base; /* Base class - must be first */
149: multiplexGroup *pGroup; /* The underlying group of files */
150: };
151:
152: /************************* Global Variables **********************************/
153: /*
154: ** All global variables used by this file are containing within the following
155: ** gMultiplex structure.
156: */
157: static struct {
158: /* The pOrigVfs is the real, original underlying VFS implementation.
159: ** Most operations pass-through to the real VFS. This value is read-only
160: ** during operation. It is only modified at start-time and thus does not
161: ** require a mutex.
162: */
163: sqlite3_vfs *pOrigVfs;
164:
165: /* The sThisVfs is the VFS structure used by this shim. It is initialized
166: ** at start-time and thus does not require a mutex
167: */
168: sqlite3_vfs sThisVfs;
169:
170: /* The sIoMethods defines the methods used by sqlite3_file objects
171: ** associated with this shim. It is initialized at start-time and does
172: ** not require a mutex.
173: **
174: ** When the underlying VFS is called to open a file, it might return
175: ** either a version 1 or a version 2 sqlite3_file object. This shim
176: ** has to create a wrapper sqlite3_file of the same version. Hence
177: ** there are two I/O method structures, one for version 1 and the other
178: ** for version 2.
179: */
180: sqlite3_io_methods sIoMethodsV1;
181: sqlite3_io_methods sIoMethodsV2;
182:
183: /* True when this shim has been initialized.
184: */
185: int isInitialized;
186:
187: /* For run-time access any of the other global data structures in this
188: ** shim, the following mutex must be held.
189: */
190: sqlite3_mutex *pMutex;
191:
192: /* List of multiplexGroup objects.
193: */
194: multiplexGroup *pGroups;
195: } gMultiplex;
196:
197: /************************* Utility Routines *********************************/
198: /*
199: ** Acquire and release the mutex used to serialize access to the
200: ** list of multiplexGroups.
201: */
202: static void multiplexEnter(void){ sqlite3_mutex_enter(gMultiplex.pMutex); }
203: static void multiplexLeave(void){ sqlite3_mutex_leave(gMultiplex.pMutex); }
204:
205: /*
206: ** Compute a string length that is limited to what can be stored in
207: ** lower 30 bits of a 32-bit signed integer.
208: **
209: ** The value returned will never be negative. Nor will it ever be greater
210: ** than the actual length of the string. For very long strings (greater
211: ** than 1GiB) the value returned might be less than the true string length.
212: */
213: static int multiplexStrlen30(const char *z){
214: const char *z2 = z;
215: if( z==0 ) return 0;
216: while( *z2 ){ z2++; }
217: return 0x3fffffff & (int)(z2 - z);
218: }
219:
220: /*
221: ** Generate the file-name for chunk iChunk of the group with base name
222: ** zBase. The file-name is written to buffer zOut before returning. Buffer
223: ** zOut must be allocated by the caller so that it is at least (nBase+5)
224: ** bytes in size, where nBase is the length of zBase, not including the
225: ** nul-terminator.
226: **
227: ** If iChunk is 0 (or 400 - the number for the first journal file chunk),
228: ** the output is a copy of the input string. Otherwise, if
229: ** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain
230: ** a "." character, then the output is a copy of the input string with the
231: ** three-digit zero-padded decimal representation if iChunk appended to it.
232: ** For example:
233: **
234: ** zBase="test.db", iChunk=4 -> zOut="test.db004"
235: **
236: ** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains
237: ** a "." character, then everything after the "." is replaced by the
238: ** three-digit representation of iChunk.
239: **
240: ** zBase="test.db", iChunk=4 -> zOut="test.004"
241: **
242: ** The output buffer string is terminated by 2 0x00 bytes. This makes it safe
243: ** to pass to sqlite3_uri_parameter() and similar.
244: */
245: static void multiplexFilename(
246: const char *zBase, /* Filename for chunk 0 */
247: int nBase, /* Size of zBase in bytes (without \0) */
248: int flags, /* Flags used to open file */
249: int iChunk, /* Chunk to generate filename for */
250: char *zOut /* Buffer to write generated name to */
251: ){
252: int n = nBase;
253: memcpy(zOut, zBase, n+1);
254: if( iChunk!=0 && iChunk!=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){
255: #ifdef SQLITE_ENABLE_8_3_NAMES
256: int i;
257: for(i=n-1; i>0 && i>=n-4 && zOut[i]!='.'; i--){}
258: if( i>=n-4 ) n = i+1;
259: if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
260: /* The extensions on overflow files for main databases are 001, 002,
261: ** 003 and so forth. To avoid name collisions, add 400 to the
262: ** extensions of journal files so that they are 401, 402, 403, ....
263: */
264: iChunk += SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET;
265: }
266: #endif
267: sqlite3_snprintf(4,&zOut[n],"%03d",iChunk);
268: n += 3;
269: }
270:
271: assert( zOut[n]=='\0' );
272: zOut[n+1] = '\0';
273: }
274:
275: /* Compute the filename for the iChunk-th chunk
276: */
277: static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){
278: if( iChunk>=pGroup->nReal ){
279: struct multiplexReal *p;
280: p = sqlite3_realloc(pGroup->aReal, (iChunk+1)*sizeof(*p));
281: if( p==0 ){
282: return SQLITE_NOMEM;
283: }
284: memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal));
285: pGroup->aReal = p;
286: pGroup->nReal = iChunk+1;
287: }
288: if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){
289: char *z;
290: int n = pGroup->nName;
291: pGroup->aReal[iChunk].z = z = sqlite3_malloc( n+5 );
292: if( z==0 ){
293: return SQLITE_NOMEM;
294: }
295: multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z);
296: }
297: return SQLITE_OK;
298: }
299:
300: /* Translate an sqlite3_file* that is really a multiplexGroup* into
301: ** the sqlite3_file* for the underlying original VFS.
302: **
303: ** For chunk 0, the pGroup->flags determines whether or not a new file
304: ** is created if it does not already exist. For chunks 1 and higher, the
305: ** file is created only if createFlag is 1.
306: */
307: static sqlite3_file *multiplexSubOpen(
308: multiplexGroup *pGroup, /* The multiplexor group */
309: int iChunk, /* Which chunk to open. 0==original file */
310: int *rc, /* Result code in and out */
311: int *pOutFlags, /* Output flags */
312: int createFlag /* True to create if iChunk>0 */
313: ){
314: sqlite3_file *pSubOpen = 0;
315: sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
316:
317: #ifdef SQLITE_ENABLE_8_3_NAMES
318: /* If JOURNAL_8_3_OFFSET is set to (say) 400, then any overflow files are
319: ** part of a database journal are named db.401, db.402, and so on. A
320: ** database may therefore not grow to larger than 400 chunks. Attempting
321: ** to open chunk 401 indicates the database is full. */
322: if( iChunk>=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){
323: *rc = SQLITE_FULL;
324: return 0;
325: }
326: #endif
327:
328: *rc = multiplexSubFilename(pGroup, iChunk);
329: if( (*rc)==SQLITE_OK && (pSubOpen = pGroup->aReal[iChunk].p)==0 ){
330: int flags, bExists;
331: flags = pGroup->flags;
332: if( createFlag ){
333: flags |= SQLITE_OPEN_CREATE;
334: }else if( iChunk==0 ){
335: /* Fall through */
336: }else if( pGroup->aReal[iChunk].z==0 ){
337: return 0;
338: }else{
339: *rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[iChunk].z,
340: SQLITE_ACCESS_EXISTS, &bExists);
341: if( *rc || !bExists ) return 0;
342: flags &= ~SQLITE_OPEN_CREATE;
343: }
344: pSubOpen = sqlite3_malloc( pOrigVfs->szOsFile );
345: if( pSubOpen==0 ){
346: *rc = SQLITE_IOERR_NOMEM;
347: return 0;
348: }
349: pGroup->aReal[iChunk].p = pSubOpen;
350: *rc = pOrigVfs->xOpen(pOrigVfs, pGroup->aReal[iChunk].z, pSubOpen,
351: flags, pOutFlags);
352: if( (*rc)!=SQLITE_OK ){
353: sqlite3_free(pSubOpen);
354: pGroup->aReal[iChunk].p = 0;
355: return 0;
356: }
357: }
358: return pSubOpen;
359: }
360:
361: /*
362: ** Return the size, in bytes, of chunk number iChunk. If that chunk
363: ** does not exist, then return 0. This function does not distingish between
364: ** non-existant files and zero-length files.
365: */
366: static sqlite3_int64 multiplexSubSize(
367: multiplexGroup *pGroup, /* The multiplexor group */
368: int iChunk, /* Which chunk to open. 0==original file */
369: int *rc /* Result code in and out */
370: ){
371: sqlite3_file *pSub;
372: sqlite3_int64 sz = 0;
373:
374: if( *rc ) return 0;
375: pSub = multiplexSubOpen(pGroup, iChunk, rc, NULL, 0);
376: if( pSub==0 ) return 0;
377: *rc = pSub->pMethods->xFileSize(pSub, &sz);
378: return sz;
379: }
380:
381: /*
382: ** This is the implementation of the multiplex_control() SQL function.
383: */
384: static void multiplexControlFunc(
385: sqlite3_context *context,
386: int argc,
387: sqlite3_value **argv
388: ){
389: int rc = SQLITE_OK;
390: sqlite3 *db = sqlite3_context_db_handle(context);
391: int op;
392: int iVal;
393:
394: if( !db || argc!=2 ){
395: rc = SQLITE_ERROR;
396: }else{
397: /* extract params */
398: op = sqlite3_value_int(argv[0]);
399: iVal = sqlite3_value_int(argv[1]);
400: /* map function op to file_control op */
401: switch( op ){
402: case 1:
403: op = MULTIPLEX_CTRL_ENABLE;
404: break;
405: case 2:
406: op = MULTIPLEX_CTRL_SET_CHUNK_SIZE;
407: break;
408: case 3:
409: op = MULTIPLEX_CTRL_SET_MAX_CHUNKS;
410: break;
411: default:
412: rc = SQLITE_NOTFOUND;
413: break;
414: }
415: }
416: if( rc==SQLITE_OK ){
417: rc = sqlite3_file_control(db, 0, op, &iVal);
418: }
419: sqlite3_result_error_code(context, rc);
420: }
421:
422: /*
423: ** This is the entry point to register the auto-extension for the
424: ** multiplex_control() function.
425: */
426: static int multiplexFuncInit(
427: sqlite3 *db,
428: char **pzErrMsg,
429: const sqlite3_api_routines *pApi
430: ){
431: int rc;
432: rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY,
433: 0, multiplexControlFunc, 0, 0);
434: return rc;
435: }
436:
437: /*
438: ** Close a single sub-file in the connection group.
439: */
440: static void multiplexSubClose(
441: multiplexGroup *pGroup,
442: int iChunk,
443: sqlite3_vfs *pOrigVfs
444: ){
445: sqlite3_file *pSubOpen = pGroup->aReal[iChunk].p;
446: if( pSubOpen ){
447: pSubOpen->pMethods->xClose(pSubOpen);
448: if( pOrigVfs && pGroup->aReal[iChunk].z ){
449: pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
450: }
451: sqlite3_free(pGroup->aReal[iChunk].p);
452: }
453: sqlite3_free(pGroup->aReal[iChunk].z);
454: memset(&pGroup->aReal[iChunk], 0, sizeof(pGroup->aReal[iChunk]));
455: }
456:
457: /*
458: ** Deallocate memory held by a multiplexGroup
459: */
460: static void multiplexFreeComponents(multiplexGroup *pGroup){
461: int i;
462: for(i=0; i<pGroup->nReal; i++){ multiplexSubClose(pGroup, i, 0); }
463: sqlite3_free(pGroup->aReal);
464: pGroup->aReal = 0;
465: pGroup->nReal = 0;
466: }
467:
468:
469: /************************* VFS Method Wrappers *****************************/
470:
471: /*
472: ** This is the xOpen method used for the "multiplex" VFS.
473: **
474: ** Most of the work is done by the underlying original VFS. This method
475: ** simply links the new file into the appropriate multiplex group if it is a
476: ** file that needs to be tracked.
477: */
478: static int multiplexOpen(
479: sqlite3_vfs *pVfs, /* The multiplex VFS */
480: const char *zName, /* Name of file to be opened */
481: sqlite3_file *pConn, /* Fill in this file descriptor */
482: int flags, /* Flags to control the opening */
483: int *pOutFlags /* Flags showing results of opening */
484: ){
485: int rc = SQLITE_OK; /* Result code */
486: multiplexConn *pMultiplexOpen; /* The new multiplex file descriptor */
487: multiplexGroup *pGroup; /* Corresponding multiplexGroup object */
488: sqlite3_file *pSubOpen = 0; /* Real file descriptor */
489: sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
490: int nName;
491: int sz;
492: char *zToFree = 0;
493:
494: UNUSED_PARAMETER(pVfs);
495: memset(pConn, 0, pVfs->szOsFile);
496: assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) );
497:
498: /* We need to create a group structure and manage
499: ** access to this group of files.
500: */
501: multiplexEnter();
502: pMultiplexOpen = (multiplexConn*)pConn;
503:
504: if( rc==SQLITE_OK ){
505: /* allocate space for group */
506: nName = zName ? multiplexStrlen30(zName) : 0;
507: sz = sizeof(multiplexGroup) /* multiplexGroup */
508: + nName + 1; /* zName */
509: pGroup = sqlite3_malloc( sz );
510: if( pGroup==0 ){
511: rc = SQLITE_NOMEM;
512: }
513: }
514:
515: if( rc==SQLITE_OK ){
516: const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0;
517: /* assign pointers to extra space allocated */
518: memset(pGroup, 0, sz);
519: pMultiplexOpen->pGroup = pGroup;
520: pGroup->bEnabled = -1;
521: pGroup->bTruncate = sqlite3_uri_boolean(zUri, "truncate",
522: (flags & SQLITE_OPEN_MAIN_DB)==0);
523: pGroup->szChunk = sqlite3_uri_int64(zUri, "chunksize",
524: SQLITE_MULTIPLEX_CHUNK_SIZE);
525: pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff;
526: if( zName ){
527: char *p = (char *)&pGroup[1];
528: pGroup->zName = p;
529: memcpy(pGroup->zName, zName, nName+1);
530: pGroup->nName = nName;
531: }
532: if( pGroup->bEnabled ){
533: /* Make sure that the chunksize is such that the pending byte does not
534: ** falls at the end of a chunk. A region of up to 64K following
535: ** the pending byte is never written, so if the pending byte occurs
536: ** near the end of a chunk, that chunk will be too small. */
537: #ifndef SQLITE_OMIT_WSD
538: extern int sqlite3PendingByte;
539: #else
540: int sqlite3PendingByte = 0x40000000;
541: #endif
542: while( (sqlite3PendingByte % pGroup->szChunk)>=(pGroup->szChunk-65536) ){
543: pGroup->szChunk += 65536;
544: }
545: }
546: pGroup->flags = flags;
547: rc = multiplexSubFilename(pGroup, 1);
548: if( rc==SQLITE_OK ){
549: pSubOpen = multiplexSubOpen(pGroup, 0, &rc, pOutFlags, 0);
550: if( pSubOpen==0 && rc==SQLITE_OK ) rc = SQLITE_CANTOPEN;
551: }
552: if( rc==SQLITE_OK ){
553: sqlite3_int64 sz;
554:
555: rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
556: if( rc==SQLITE_OK && zName ){
557: int bExists;
558: if( sz==0 ){
559: if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
560: /* If opening a main journal file and the first chunk is zero
561: ** bytes in size, delete any subsequent chunks from the
562: ** file-system. */
563: int iChunk = 1;
564: do {
565: rc = pOrigVfs->xAccess(pOrigVfs,
566: pGroup->aReal[iChunk].z, SQLITE_ACCESS_EXISTS, &bExists
567: );
568: if( rc==SQLITE_OK && bExists ){
569: rc = pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
570: if( rc==SQLITE_OK ){
571: rc = multiplexSubFilename(pGroup, ++iChunk);
572: }
573: }
574: }while( rc==SQLITE_OK && bExists );
575: }
576: }else{
577: /* If the first overflow file exists and if the size of the main file
578: ** is different from the chunk size, that means the chunk size is set
579: ** set incorrectly. So fix it.
580: **
581: ** Or, if the first overflow file does not exist and the main file is
582: ** larger than the chunk size, that means the chunk size is too small.
583: ** But we have no way of determining the intended chunk size, so
584: ** just disable the multiplexor all togethre.
585: */
586: rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[1].z,
587: SQLITE_ACCESS_EXISTS, &bExists);
588: bExists = multiplexSubSize(pGroup, 1, &rc)>0;
589: if( rc==SQLITE_OK && bExists && sz==(sz&0xffff0000) && sz>0
590: && sz!=pGroup->szChunk ){
591: pGroup->szChunk = sz;
592: }else if( rc==SQLITE_OK && !bExists && sz>pGroup->szChunk ){
593: pGroup->bEnabled = 0;
594: }
595: }
596: }
597: }
598:
599: if( rc==SQLITE_OK ){
600: if( pSubOpen->pMethods->iVersion==1 ){
601: pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV1;
602: }else{
603: pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV2;
604: }
605: /* place this group at the head of our list */
606: pGroup->pNext = gMultiplex.pGroups;
607: if( gMultiplex.pGroups ) gMultiplex.pGroups->pPrev = pGroup;
608: gMultiplex.pGroups = pGroup;
609: }else{
610: multiplexFreeComponents(pGroup);
611: sqlite3_free(pGroup);
612: }
613: }
614: multiplexLeave();
615: sqlite3_free(zToFree);
616: return rc;
617: }
618:
619: /*
620: ** This is the xDelete method used for the "multiplex" VFS.
621: ** It attempts to delete the filename specified.
622: */
623: static int multiplexDelete(
624: sqlite3_vfs *pVfs, /* The multiplex VFS */
625: const char *zName, /* Name of file to delete */
626: int syncDir
627: ){
628: int rc;
629: sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
630: rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir);
631: if( rc==SQLITE_OK ){
632: /* If the main chunk was deleted successfully, also delete any subsequent
633: ** chunks - starting with the last (highest numbered).
634: */
635: int nName = strlen(zName);
636: char *z;
637: z = sqlite3_malloc(nName + 5);
638: if( z==0 ){
639: rc = SQLITE_IOERR_NOMEM;
640: }else{
641: int iChunk = 0;
642: int bExists;
643: do{
644: multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, ++iChunk, z);
645: rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists);
646: }while( rc==SQLITE_OK && bExists );
647: while( rc==SQLITE_OK && iChunk>1 ){
648: multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, --iChunk, z);
649: rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir);
650: }
651: }
652: sqlite3_free(z);
653: }
654: return rc;
655: }
656:
657: static int multiplexAccess(sqlite3_vfs *a, const char *b, int c, int *d){
658: return gMultiplex.pOrigVfs->xAccess(gMultiplex.pOrigVfs, b, c, d);
659: }
660: static int multiplexFullPathname(sqlite3_vfs *a, const char *b, int c, char *d){
661: return gMultiplex.pOrigVfs->xFullPathname(gMultiplex.pOrigVfs, b, c, d);
662: }
663: static void *multiplexDlOpen(sqlite3_vfs *a, const char *b){
664: return gMultiplex.pOrigVfs->xDlOpen(gMultiplex.pOrigVfs, b);
665: }
666: static void multiplexDlError(sqlite3_vfs *a, int b, char *c){
667: gMultiplex.pOrigVfs->xDlError(gMultiplex.pOrigVfs, b, c);
668: }
669: static void (*multiplexDlSym(sqlite3_vfs *a, void *b, const char *c))(void){
670: return gMultiplex.pOrigVfs->xDlSym(gMultiplex.pOrigVfs, b, c);
671: }
672: static void multiplexDlClose(sqlite3_vfs *a, void *b){
673: gMultiplex.pOrigVfs->xDlClose(gMultiplex.pOrigVfs, b);
674: }
675: static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){
676: return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c);
677: }
678: static int multiplexSleep(sqlite3_vfs *a, int b){
679: return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b);
680: }
681: static int multiplexCurrentTime(sqlite3_vfs *a, double *b){
682: return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b);
683: }
684: static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){
685: return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c);
686: }
687: static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){
688: return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b);
689: }
690:
691: /************************ I/O Method Wrappers *******************************/
692:
693: /* xClose requests get passed through to the original VFS.
694: ** We loop over all open chunk handles and close them.
695: ** The group structure for this file is unlinked from
696: ** our list of groups and freed.
697: */
698: static int multiplexClose(sqlite3_file *pConn){
699: multiplexConn *p = (multiplexConn*)pConn;
700: multiplexGroup *pGroup = p->pGroup;
701: int rc = SQLITE_OK;
702: multiplexEnter();
703: multiplexFreeComponents(pGroup);
704: /* remove from linked list */
705: if( pGroup->pNext ) pGroup->pNext->pPrev = pGroup->pPrev;
706: if( pGroup->pPrev ){
707: pGroup->pPrev->pNext = pGroup->pNext;
708: }else{
709: gMultiplex.pGroups = pGroup->pNext;
710: }
711: sqlite3_free(pGroup);
712: multiplexLeave();
713: return rc;
714: }
715:
716: /* Pass xRead requests thru to the original VFS after
717: ** determining the correct chunk to operate on.
718: ** Break up reads across chunk boundaries.
719: */
720: static int multiplexRead(
721: sqlite3_file *pConn,
722: void *pBuf,
723: int iAmt,
724: sqlite3_int64 iOfst
725: ){
726: multiplexConn *p = (multiplexConn*)pConn;
727: multiplexGroup *pGroup = p->pGroup;
728: int rc = SQLITE_OK;
729: multiplexEnter();
730: if( !pGroup->bEnabled ){
731: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
732: if( pSubOpen==0 ){
733: rc = SQLITE_IOERR_READ;
734: }else{
735: rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
736: }
737: }else{
738: while( iAmt > 0 ){
739: int i = (int)(iOfst / pGroup->szChunk);
740: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
741: if( pSubOpen ){
742: int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - pGroup->szChunk;
743: if( extra<0 ) extra = 0;
744: iAmt -= extra;
745: rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt,
746: iOfst % pGroup->szChunk);
747: if( rc!=SQLITE_OK ) break;
748: pBuf = (char *)pBuf + iAmt;
749: iOfst += iAmt;
750: iAmt = extra;
751: }else{
752: rc = SQLITE_IOERR_READ;
753: break;
754: }
755: }
756: }
757: multiplexLeave();
758: return rc;
759: }
760:
761: /* Pass xWrite requests thru to the original VFS after
762: ** determining the correct chunk to operate on.
763: ** Break up writes across chunk boundaries.
764: */
765: static int multiplexWrite(
766: sqlite3_file *pConn,
767: const void *pBuf,
768: int iAmt,
769: sqlite3_int64 iOfst
770: ){
771: multiplexConn *p = (multiplexConn*)pConn;
772: multiplexGroup *pGroup = p->pGroup;
773: int rc = SQLITE_OK;
774: multiplexEnter();
775: if( !pGroup->bEnabled ){
776: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
777: if( pSubOpen==0 ){
778: rc = SQLITE_IOERR_WRITE;
779: }else{
780: rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
781: }
782: }else{
783: while( rc==SQLITE_OK && iAmt>0 ){
784: int i = (int)(iOfst / pGroup->szChunk);
785: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
786: if( pSubOpen ){
787: int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) -
788: pGroup->szChunk;
789: if( extra<0 ) extra = 0;
790: iAmt -= extra;
791: rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt,
792: iOfst % pGroup->szChunk);
793: pBuf = (char *)pBuf + iAmt;
794: iOfst += iAmt;
795: iAmt = extra;
796: }
797: }
798: }
799: multiplexLeave();
800: return rc;
801: }
802:
803: /* Pass xTruncate requests thru to the original VFS after
804: ** determining the correct chunk to operate on. Delete any
805: ** chunks above the truncate mark.
806: */
807: static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
808: multiplexConn *p = (multiplexConn*)pConn;
809: multiplexGroup *pGroup = p->pGroup;
810: int rc = SQLITE_OK;
811: multiplexEnter();
812: if( !pGroup->bEnabled ){
813: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
814: if( pSubOpen==0 ){
815: rc = SQLITE_IOERR_TRUNCATE;
816: }else{
817: rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
818: }
819: }else{
820: int i;
821: int iBaseGroup = (int)(size / pGroup->szChunk);
822: sqlite3_file *pSubOpen;
823: sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
824: /* delete the chunks above the truncate limit */
825: for(i = pGroup->nReal-1; i>iBaseGroup && rc==SQLITE_OK; i--){
826: if( pGroup->bTruncate ){
827: multiplexSubClose(pGroup, i, pOrigVfs);
828: }else{
829: pSubOpen = multiplexSubOpen(pGroup, i, &rc, 0, 0);
830: if( pSubOpen ){
831: rc = pSubOpen->pMethods->xTruncate(pSubOpen, 0);
832: }
833: }
834: }
835: if( rc==SQLITE_OK ){
836: pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0);
837: if( pSubOpen ){
838: rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk);
839: }
840: }
841: if( rc ) rc = SQLITE_IOERR_TRUNCATE;
842: }
843: multiplexLeave();
844: return rc;
845: }
846:
847: /* Pass xSync requests through to the original VFS without change
848: */
849: static int multiplexSync(sqlite3_file *pConn, int flags){
850: multiplexConn *p = (multiplexConn*)pConn;
851: multiplexGroup *pGroup = p->pGroup;
852: int rc = SQLITE_OK;
853: int i;
854: multiplexEnter();
855: for(i=0; i<pGroup->nReal; i++){
856: sqlite3_file *pSubOpen = pGroup->aReal[i].p;
857: if( pSubOpen ){
858: int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags);
859: if( rc2!=SQLITE_OK ) rc = rc2;
860: }
861: }
862: multiplexLeave();
863: return rc;
864: }
865:
866: /* Pass xFileSize requests through to the original VFS.
867: ** Aggregate the size of all the chunks before returning.
868: */
869: static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
870: multiplexConn *p = (multiplexConn*)pConn;
871: multiplexGroup *pGroup = p->pGroup;
872: int rc = SQLITE_OK;
873: int i;
874: multiplexEnter();
875: if( !pGroup->bEnabled ){
876: sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
877: if( pSubOpen==0 ){
878: rc = SQLITE_IOERR_FSTAT;
879: }else{
880: rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
881: }
882: }else{
883: *pSize = 0;
884: for(i=0; rc==SQLITE_OK; i++){
885: sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc);
886: if( sz==0 ) break;
887: *pSize = i*(sqlite3_int64)pGroup->szChunk + sz;
888: }
889: }
890: multiplexLeave();
891: return rc;
892: }
893:
894: /* Pass xLock requests through to the original VFS unchanged.
895: */
896: static int multiplexLock(sqlite3_file *pConn, int lock){
897: multiplexConn *p = (multiplexConn*)pConn;
898: int rc;
899: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
900: if( pSubOpen ){
901: return pSubOpen->pMethods->xLock(pSubOpen, lock);
902: }
903: return SQLITE_BUSY;
904: }
905:
906: /* Pass xUnlock requests through to the original VFS unchanged.
907: */
908: static int multiplexUnlock(sqlite3_file *pConn, int lock){
909: multiplexConn *p = (multiplexConn*)pConn;
910: int rc;
911: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
912: if( pSubOpen ){
913: return pSubOpen->pMethods->xUnlock(pSubOpen, lock);
914: }
915: return SQLITE_IOERR_UNLOCK;
916: }
917:
918: /* Pass xCheckReservedLock requests through to the original VFS unchanged.
919: */
920: static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){
921: multiplexConn *p = (multiplexConn*)pConn;
922: int rc;
923: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
924: if( pSubOpen ){
925: return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut);
926: }
927: return SQLITE_IOERR_CHECKRESERVEDLOCK;
928: }
929:
930: /* Pass xFileControl requests through to the original VFS unchanged,
931: ** except for any MULTIPLEX_CTRL_* requests here.
932: */
933: static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
934: multiplexConn *p = (multiplexConn*)pConn;
935: multiplexGroup *pGroup = p->pGroup;
936: int rc = SQLITE_ERROR;
937: sqlite3_file *pSubOpen;
938:
939: if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
940: switch( op ){
941: case MULTIPLEX_CTRL_ENABLE:
942: if( pArg ) {
943: int bEnabled = *(int *)pArg;
944: pGroup->bEnabled = bEnabled;
945: rc = SQLITE_OK;
946: }
947: break;
948: case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
949: if( pArg ) {
950: unsigned int szChunk = *(unsigned*)pArg;
951: if( szChunk<1 ){
952: rc = SQLITE_MISUSE;
953: }else{
954: /* Round up to nearest multiple of MAX_PAGE_SIZE. */
955: szChunk = (szChunk + (MAX_PAGE_SIZE-1));
956: szChunk &= ~(MAX_PAGE_SIZE-1);
957: pGroup->szChunk = szChunk;
958: rc = SQLITE_OK;
959: }
960: }
961: break;
962: case MULTIPLEX_CTRL_SET_MAX_CHUNKS:
963: rc = SQLITE_OK;
964: break;
965: case SQLITE_FCNTL_SIZE_HINT:
966: case SQLITE_FCNTL_CHUNK_SIZE:
967: /* no-op these */
968: rc = SQLITE_OK;
969: break;
970: default:
971: pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
972: if( pSubOpen ){
973: rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
974: if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
975: *(char**)pArg = sqlite3_mprintf("multiplex/%z", *(char**)pArg);
976: }
977: }
978: break;
979: }
980: return rc;
981: }
982:
983: /* Pass xSectorSize requests through to the original VFS unchanged.
984: */
985: static int multiplexSectorSize(sqlite3_file *pConn){
986: multiplexConn *p = (multiplexConn*)pConn;
987: int rc;
988: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
989: if( pSubOpen && pSubOpen->pMethods->xSectorSize ){
990: return pSubOpen->pMethods->xSectorSize(pSubOpen);
991: }
992: return DEFAULT_SECTOR_SIZE;
993: }
994:
995: /* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
996: */
997: static int multiplexDeviceCharacteristics(sqlite3_file *pConn){
998: multiplexConn *p = (multiplexConn*)pConn;
999: int rc;
1000: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
1001: if( pSubOpen ){
1002: return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen);
1003: }
1004: return 0;
1005: }
1006:
1007: /* Pass xShmMap requests through to the original VFS unchanged.
1008: */
1009: static int multiplexShmMap(
1010: sqlite3_file *pConn, /* Handle open on database file */
1011: int iRegion, /* Region to retrieve */
1012: int szRegion, /* Size of regions */
1013: int bExtend, /* True to extend file if necessary */
1014: void volatile **pp /* OUT: Mapped memory */
1015: ){
1016: multiplexConn *p = (multiplexConn*)pConn;
1017: int rc;
1018: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
1019: if( pSubOpen ){
1020: return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend,pp);
1021: }
1022: return SQLITE_IOERR;
1023: }
1024:
1025: /* Pass xShmLock requests through to the original VFS unchanged.
1026: */
1027: static int multiplexShmLock(
1028: sqlite3_file *pConn, /* Database file holding the shared memory */
1029: int ofst, /* First lock to acquire or release */
1030: int n, /* Number of locks to acquire or release */
1031: int flags /* What to do with the lock */
1032: ){
1033: multiplexConn *p = (multiplexConn*)pConn;
1034: int rc;
1035: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
1036: if( pSubOpen ){
1037: return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
1038: }
1039: return SQLITE_BUSY;
1040: }
1041:
1042: /* Pass xShmBarrier requests through to the original VFS unchanged.
1043: */
1044: static void multiplexShmBarrier(sqlite3_file *pConn){
1045: multiplexConn *p = (multiplexConn*)pConn;
1046: int rc;
1047: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
1048: if( pSubOpen ){
1049: pSubOpen->pMethods->xShmBarrier(pSubOpen);
1050: }
1051: }
1052:
1053: /* Pass xShmUnmap requests through to the original VFS unchanged.
1054: */
1055: static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){
1056: multiplexConn *p = (multiplexConn*)pConn;
1057: int rc;
1058: sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
1059: if( pSubOpen ){
1060: return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
1061: }
1062: return SQLITE_OK;
1063: }
1064:
1065: /************************** Public Interfaces *****************************/
1066: /*
1067: ** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
1068: **
1069: ** Use the VFS named zOrigVfsName as the VFS that does the actual work.
1070: ** Use the default if zOrigVfsName==NULL.
1071: **
1072: ** The multiplex VFS shim is named "multiplex". It will become the default
1073: ** VFS if makeDefault is non-zero.
1074: **
1075: ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
1076: ** during start-up.
1077: */
1078: int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
1079: sqlite3_vfs *pOrigVfs;
1080: if( gMultiplex.isInitialized ) return SQLITE_MISUSE;
1081: pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
1082: if( pOrigVfs==0 ) return SQLITE_ERROR;
1083: assert( pOrigVfs!=&gMultiplex.sThisVfs );
1084: gMultiplex.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
1085: if( !gMultiplex.pMutex ){
1086: return SQLITE_NOMEM;
1087: }
1088: gMultiplex.pGroups = NULL;
1089: gMultiplex.isInitialized = 1;
1090: gMultiplex.pOrigVfs = pOrigVfs;
1091: gMultiplex.sThisVfs = *pOrigVfs;
1092: gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
1093: gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
1094: gMultiplex.sThisVfs.xOpen = multiplexOpen;
1095: gMultiplex.sThisVfs.xDelete = multiplexDelete;
1096: gMultiplex.sThisVfs.xAccess = multiplexAccess;
1097: gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname;
1098: gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen;
1099: gMultiplex.sThisVfs.xDlError = multiplexDlError;
1100: gMultiplex.sThisVfs.xDlSym = multiplexDlSym;
1101: gMultiplex.sThisVfs.xDlClose = multiplexDlClose;
1102: gMultiplex.sThisVfs.xRandomness = multiplexRandomness;
1103: gMultiplex.sThisVfs.xSleep = multiplexSleep;
1104: gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime;
1105: gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError;
1106: gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64;
1107:
1108: gMultiplex.sIoMethodsV1.iVersion = 1;
1109: gMultiplex.sIoMethodsV1.xClose = multiplexClose;
1110: gMultiplex.sIoMethodsV1.xRead = multiplexRead;
1111: gMultiplex.sIoMethodsV1.xWrite = multiplexWrite;
1112: gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate;
1113: gMultiplex.sIoMethodsV1.xSync = multiplexSync;
1114: gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize;
1115: gMultiplex.sIoMethodsV1.xLock = multiplexLock;
1116: gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock;
1117: gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock;
1118: gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl;
1119: gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize;
1120: gMultiplex.sIoMethodsV1.xDeviceCharacteristics =
1121: multiplexDeviceCharacteristics;
1122: gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1;
1123: gMultiplex.sIoMethodsV2.iVersion = 2;
1124: gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap;
1125: gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock;
1126: gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
1127: gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
1128: sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);
1129:
1130: sqlite3_auto_extension((void*)multiplexFuncInit);
1131:
1132: return SQLITE_OK;
1133: }
1134:
1135: /*
1136: ** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
1137: **
1138: ** All SQLite database connections must be closed before calling this
1139: ** routine.
1140: **
1141: ** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once while
1142: ** shutting down in order to free all remaining multiplex groups.
1143: */
1144: int sqlite3_multiplex_shutdown(void){
1145: if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE;
1146: if( gMultiplex.pGroups ) return SQLITE_MISUSE;
1147: gMultiplex.isInitialized = 0;
1148: sqlite3_mutex_free(gMultiplex.pMutex);
1149: sqlite3_vfs_unregister(&gMultiplex.sThisVfs);
1150: memset(&gMultiplex, 0, sizeof(gMultiplex));
1151: return SQLITE_OK;
1152: }
1153:
1154: /***************************** Test Code ***********************************/
1155: #ifdef SQLITE_TEST
1156: #include <tcl.h>
1157: extern const char *sqlite3TestErrorName(int);
1158:
1159:
1160: /*
1161: ** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT
1162: */
1163: static int test_multiplex_initialize(
1164: void * clientData,
1165: Tcl_Interp *interp,
1166: int objc,
1167: Tcl_Obj *CONST objv[]
1168: ){
1169: const char *zName; /* Name of new multiplex VFS */
1170: int makeDefault; /* True to make the new VFS the default */
1171: int rc; /* Value returned by multiplex_initialize() */
1172:
1173: UNUSED_PARAMETER(clientData);
1174:
1175: /* Process arguments */
1176: if( objc!=3 ){
1177: Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
1178: return TCL_ERROR;
1179: }
1180: zName = Tcl_GetString(objv[1]);
1181: if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
1182: if( zName[0]=='\0' ) zName = 0;
1183:
1184: /* Call sqlite3_multiplex_initialize() */
1185: rc = sqlite3_multiplex_initialize(zName, makeDefault);
1186: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
1187:
1188: return TCL_OK;
1189: }
1190:
1191: /*
1192: ** tclcmd: sqlite3_multiplex_shutdown
1193: */
1194: static int test_multiplex_shutdown(
1195: void * clientData,
1196: Tcl_Interp *interp,
1197: int objc,
1198: Tcl_Obj *CONST objv[]
1199: ){
1200: int rc; /* Value returned by multiplex_shutdown() */
1201:
1202: UNUSED_PARAMETER(clientData);
1203:
1204: if( objc!=1 ){
1205: Tcl_WrongNumArgs(interp, 1, objv, "");
1206: return TCL_ERROR;
1207: }
1208:
1209: /* Call sqlite3_multiplex_shutdown() */
1210: rc = sqlite3_multiplex_shutdown();
1211: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
1212:
1213: return TCL_OK;
1214: }
1215:
1216: /*
1217: ** tclcmd: sqlite3_multiplex_dump
1218: */
1219: static int test_multiplex_dump(
1220: void * clientData,
1221: Tcl_Interp *interp,
1222: int objc,
1223: Tcl_Obj *CONST objv[]
1224: ){
1225: Tcl_Obj *pResult;
1226: Tcl_Obj *pGroupTerm;
1227: multiplexGroup *pGroup;
1228: int i;
1229: int nChunks = 0;
1230:
1231: UNUSED_PARAMETER(clientData);
1232: UNUSED_PARAMETER(objc);
1233: UNUSED_PARAMETER(objv);
1234:
1235: pResult = Tcl_NewObj();
1236: multiplexEnter();
1237: for(pGroup=gMultiplex.pGroups; pGroup; pGroup=pGroup->pNext){
1238: pGroupTerm = Tcl_NewObj();
1239:
1240: if( pGroup->zName ){
1241: pGroup->zName[pGroup->nName] = '\0';
1242: Tcl_ListObjAppendElement(interp, pGroupTerm,
1243: Tcl_NewStringObj(pGroup->zName, -1));
1244: }else{
1245: Tcl_ListObjAppendElement(interp, pGroupTerm, Tcl_NewObj());
1246: }
1247: Tcl_ListObjAppendElement(interp, pGroupTerm,
1248: Tcl_NewIntObj(pGroup->nName));
1249: Tcl_ListObjAppendElement(interp, pGroupTerm,
1250: Tcl_NewIntObj(pGroup->flags));
1251:
1252: /* count number of chunks with open handles */
1253: for(i=0; i<pGroup->nReal; i++){
1254: if( pGroup->aReal[i].p!=0 ) nChunks++;
1255: }
1256: Tcl_ListObjAppendElement(interp, pGroupTerm,
1257: Tcl_NewIntObj(nChunks));
1258:
1259: Tcl_ListObjAppendElement(interp, pGroupTerm,
1260: Tcl_NewIntObj(pGroup->szChunk));
1261: Tcl_ListObjAppendElement(interp, pGroupTerm,
1262: Tcl_NewIntObj(pGroup->nReal));
1263:
1264: Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
1265: }
1266: multiplexLeave();
1267: Tcl_SetObjResult(interp, pResult);
1268: return TCL_OK;
1269: }
1270:
1271: /*
1272: ** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
1273: */
1274: static int test_multiplex_control(
1275: ClientData cd,
1276: Tcl_Interp *interp,
1277: int objc,
1278: Tcl_Obj *CONST objv[]
1279: ){
1280: int rc; /* Return code from file_control() */
1281: int idx; /* Index in aSub[] */
1282: Tcl_CmdInfo cmdInfo; /* Command info structure for HANDLE */
1283: sqlite3 *db; /* Underlying db handle for HANDLE */
1284: int iValue = 0;
1285: void *pArg = 0;
1286:
1287: struct SubCommand {
1288: const char *zName;
1289: int op;
1290: int argtype;
1291: } aSub[] = {
1292: { "enable", MULTIPLEX_CTRL_ENABLE, 1 },
1293: { "chunk_size", MULTIPLEX_CTRL_SET_CHUNK_SIZE, 1 },
1294: { "max_chunks", MULTIPLEX_CTRL_SET_MAX_CHUNKS, 1 },
1295: { 0, 0, 0 }
1296: };
1297:
1298: if( objc!=5 ){
1299: Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE");
1300: return TCL_ERROR;
1301: }
1302:
1303: if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
1304: Tcl_AppendResult(interp, "expected database handle, got \"", 0);
1305: Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0);
1306: return TCL_ERROR;
1307: }else{
1308: db = *(sqlite3 **)cmdInfo.objClientData;
1309: }
1310:
1311: rc = Tcl_GetIndexFromObjStruct(
1312: interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx
1313: );
1314: if( rc!=TCL_OK ) return rc;
1315:
1316: switch( aSub[idx].argtype ){
1317: case 1:
1318: if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){
1319: return TCL_ERROR;
1320: }
1321: pArg = (void *)&iValue;
1322: break;
1323: default:
1324: Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND");
1325: return TCL_ERROR;
1326: }
1327:
1328: rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg);
1329: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
1330: return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR;
1331: }
1332:
1333: /*
1334: ** This routine registers the custom TCL commands defined in this
1335: ** module. This should be the only procedure visible from outside
1336: ** of this module.
1337: */
1338: int Sqlitemultiplex_Init(Tcl_Interp *interp){
1339: static struct {
1340: char *zName;
1341: Tcl_ObjCmdProc *xProc;
1342: } aCmd[] = {
1343: { "sqlite3_multiplex_initialize", test_multiplex_initialize },
1344: { "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
1345: { "sqlite3_multiplex_dump", test_multiplex_dump },
1346: { "sqlite3_multiplex_control", test_multiplex_control },
1347: };
1348: int i;
1349:
1350: for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
1351: Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
1352: }
1353:
1354: return TCL_OK;
1355: }
1356: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_multiplex.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src