| Index: third_party/sqlite/src/src/test_quota.c
|
| diff --git a/third_party/sqlite/src/src/test_quota.c b/third_party/sqlite/src/src/test_quota.c
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..3c6db4d7cdd86fc90a8077b3f04d5093e53ebcfc
|
| --- /dev/null
|
| +++ b/third_party/sqlite/src/src/test_quota.c
|
| @@ -0,0 +1,952 @@
|
| +/*
|
| +** 2010 September 31
|
| +**
|
| +** The author disclaims copyright to this source code. In place of
|
| +** a legal notice, here is a blessing:
|
| +**
|
| +** May you do good and not evil.
|
| +** May you find forgiveness for yourself and forgive others.
|
| +** May you share freely, never taking more than you give.
|
| +**
|
| +*************************************************************************
|
| +**
|
| +** This file contains a VFS "shim" - a layer that sits in between the
|
| +** pager and the real VFS.
|
| +**
|
| +** This particular shim enforces a quota system on files. One or more
|
| +** database files are in a "quota group" that is defined by a GLOB
|
| +** pattern. A quota is set for the combined size of all files in the
|
| +** the group. A quota of zero means "no limit". If the total size
|
| +** of all files in the quota group is greater than the limit, then
|
| +** write requests that attempt to enlarge a file fail with SQLITE_FULL.
|
| +**
|
| +** However, before returning SQLITE_FULL, the write requests invoke
|
| +** a callback function that is configurable for each quota group.
|
| +** This callback has the opportunity to enlarge the quota. If the
|
| +** callback does enlarge the quota such that the total size of all
|
| +** files within the group is less than the new quota, then the write
|
| +** continues as if nothing had happened.
|
| +*/
|
| +#include "sqlite3.h"
|
| +#include <string.h>
|
| +#include <assert.h>
|
| +
|
| +/*
|
| +** For an build without mutexes, no-op the mutex calls.
|
| +*/
|
| +#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE==0
|
| +#define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8)
|
| +#define sqlite3_mutex_free(X)
|
| +#define sqlite3_mutex_enter(X)
|
| +#define sqlite3_mutex_try(X) SQLITE_OK
|
| +#define sqlite3_mutex_leave(X)
|
| +#define sqlite3_mutex_held(X) ((void)(X),1)
|
| +#define sqlite3_mutex_notheld(X) ((void)(X),1)
|
| +#endif /* SQLITE_THREADSAFE==0 */
|
| +
|
| +
|
| +/************************ Object Definitions ******************************/
|
| +
|
| +/* Forward declaration of all object types */
|
| +typedef struct quotaGroup quotaGroup;
|
| +typedef struct quotaConn quotaConn;
|
| +typedef struct quotaFile quotaFile;
|
| +
|
| +/*
|
| +** A "quota group" is a collection of files whose collective size we want
|
| +** to limit. Each quota group is defined by a GLOB pattern.
|
| +**
|
| +** There is an instance of the following object for each defined quota
|
| +** group. This object records the GLOB pattern that defines which files
|
| +** belong to the quota group. The object also remembers the size limit
|
| +** for the group (the quota) and the callback to be invoked when the
|
| +** sum of the sizes of the files within the group goes over the limit.
|
| +**
|
| +** A quota group must be established (using sqlite3_quota_set(...))
|
| +** prior to opening any of the database connections that access files
|
| +** within the quota group.
|
| +*/
|
| +struct quotaGroup {
|
| + const char *zPattern; /* Filename pattern to be quotaed */
|
| + sqlite3_int64 iLimit; /* Upper bound on total file size */
|
| + sqlite3_int64 iSize; /* Current size of all files */
|
| + void (*xCallback)( /* Callback invoked when going over quota */
|
| + const char *zFilename, /* Name of file whose size increases */
|
| + sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
| + sqlite3_int64 iSize, /* Total size of all files in the group */
|
| + void *pArg /* Client data */
|
| + );
|
| + void *pArg; /* Third argument to the xCallback() */
|
| + void (*xDestroy)(void*); /* Optional destructor for pArg */
|
| + quotaGroup *pNext, **ppPrev; /* Doubly linked list of all quota objects */
|
| + quotaFile *pFiles; /* Files within this group */
|
| +};
|
| +
|
| +/*
|
| +** An instance of this structure represents a single file that is part
|
| +** of a quota group. A single file can be opened multiple times. In
|
| +** order keep multiple openings of the same file from causing the size
|
| +** of the file to count against the quota multiple times, each file
|
| +** has a unique instance of this object and multiple open connections
|
| +** to the same file each point to a single instance of this object.
|
| +*/
|
| +struct quotaFile {
|
| + char *zFilename; /* Name of this file */
|
| + quotaGroup *pGroup; /* Quota group to which this file belongs */
|
| + sqlite3_int64 iSize; /* Current size of this file */
|
| + int nRef; /* Number of times this file is open */
|
| + quotaFile *pNext, **ppPrev; /* Linked list of files in the same group */
|
| +};
|
| +
|
| +/*
|
| +** An instance of the following object represents each open connection
|
| +** to a file that participates in quota tracking. This object is a
|
| +** subclass of sqlite3_file. The sqlite3_file object for the underlying
|
| +** VFS is appended to this structure.
|
| +*/
|
| +struct quotaConn {
|
| + sqlite3_file base; /* Base class - must be first */
|
| + quotaFile *pFile; /* The underlying file */
|
| + /* The underlying VFS sqlite3_file is appended to this object */
|
| +};
|
| +
|
| +/************************* Global Variables **********************************/
|
| +/*
|
| +** All global variables used by this file are containing within the following
|
| +** gQuota structure.
|
| +*/
|
| +static struct {
|
| + /* The pOrigVfs is the real, original underlying VFS implementation.
|
| + ** Most operations pass-through to the real VFS. This value is read-only
|
| + ** during operation. It is only modified at start-time and thus does not
|
| + ** require a mutex.
|
| + */
|
| + sqlite3_vfs *pOrigVfs;
|
| +
|
| + /* The sThisVfs is the VFS structure used by this shim. It is initialized
|
| + ** at start-time and thus does not require a mutex
|
| + */
|
| + sqlite3_vfs sThisVfs;
|
| +
|
| + /* The sIoMethods defines the methods used by sqlite3_file objects
|
| + ** associated with this shim. It is initialized at start-time and does
|
| + ** not require a mutex.
|
| + **
|
| + ** When the underlying VFS is called to open a file, it might return
|
| + ** either a version 1 or a version 2 sqlite3_file object. This shim
|
| + ** has to create a wrapper sqlite3_file of the same version. Hence
|
| + ** there are two I/O method structures, one for version 1 and the other
|
| + ** for version 2.
|
| + */
|
| + sqlite3_io_methods sIoMethodsV1;
|
| + sqlite3_io_methods sIoMethodsV2;
|
| +
|
| + /* True when this shim as been initialized.
|
| + */
|
| + int isInitialized;
|
| +
|
| + /* For run-time access any of the other global data structures in this
|
| + ** shim, the following mutex must be held.
|
| + */
|
| + sqlite3_mutex *pMutex;
|
| +
|
| + /* List of quotaGroup objects.
|
| + */
|
| + quotaGroup *pGroup;
|
| +
|
| +} gQuota;
|
| +
|
| +/************************* Utility Routines *********************************/
|
| +/*
|
| +** Acquire and release the mutex used to serialize access to the
|
| +** list of quotaGroups.
|
| +*/
|
| +static void quotaEnter(void){ sqlite3_mutex_enter(gQuota.pMutex); }
|
| +static void quotaLeave(void){ sqlite3_mutex_leave(gQuota.pMutex); }
|
| +
|
| +
|
| +/* If the reference count and threshold for a quotaGroup are both
|
| +** zero, then destroy the quotaGroup.
|
| +*/
|
| +static void quotaGroupDeref(quotaGroup *pGroup){
|
| + if( pGroup->pFiles==0 && pGroup->iLimit==0 ){
|
| + *pGroup->ppPrev = pGroup->pNext;
|
| + if( pGroup->pNext ) pGroup->pNext->ppPrev = pGroup->ppPrev;
|
| + if( pGroup->xDestroy ) pGroup->xDestroy(pGroup->pArg);
|
| + sqlite3_free(pGroup);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** Return TRUE if string z matches glob pattern zGlob.
|
| +**
|
| +** Globbing rules:
|
| +**
|
| +** '*' Matches any sequence of zero or more characters.
|
| +**
|
| +** '?' Matches exactly one character.
|
| +**
|
| +** [...] Matches one character from the enclosed list of
|
| +** characters.
|
| +**
|
| +** [^...] Matches one character not in the enclosed list.
|
| +**
|
| +*/
|
| +static int quotaStrglob(const char *zGlob, const char *z){
|
| + int c, c2;
|
| + int invert;
|
| + int seen;
|
| +
|
| + while( (c = (*(zGlob++)))!=0 ){
|
| + if( c=='*' ){
|
| + while( (c=(*(zGlob++))) == '*' || c=='?' ){
|
| + if( c=='?' && (*(z++))==0 ) return 0;
|
| + }
|
| + if( c==0 ){
|
| + return 1;
|
| + }else if( c=='[' ){
|
| + while( *z && quotaStrglob(zGlob-1,z)==0 ){
|
| + z++;
|
| + }
|
| + return (*z)!=0;
|
| + }
|
| + while( (c2 = (*(z++)))!=0 ){
|
| + while( c2!=c ){
|
| + c2 = *(z++);
|
| + if( c2==0 ) return 0;
|
| + }
|
| + if( quotaStrglob(zGlob,z) ) return 1;
|
| + }
|
| + return 0;
|
| + }else if( c=='?' ){
|
| + if( (*(z++))==0 ) return 0;
|
| + }else if( c=='[' ){
|
| + int prior_c = 0;
|
| + seen = 0;
|
| + invert = 0;
|
| + c = *(z++);
|
| + if( c==0 ) return 0;
|
| + c2 = *(zGlob++);
|
| + if( c2=='^' ){
|
| + invert = 1;
|
| + c2 = *(zGlob++);
|
| + }
|
| + if( c2==']' ){
|
| + if( c==']' ) seen = 1;
|
| + c2 = *(zGlob++);
|
| + }
|
| + while( c2 && c2!=']' ){
|
| + if( c2=='-' && zGlob[0]!=']' && zGlob[0]!=0 && prior_c>0 ){
|
| + c2 = *(zGlob++);
|
| + if( c>=prior_c && c<=c2 ) seen = 1;
|
| + prior_c = 0;
|
| + }else{
|
| + if( c==c2 ){
|
| + seen = 1;
|
| + }
|
| + prior_c = c2;
|
| + }
|
| + c2 = *(zGlob++);
|
| + }
|
| + if( c2==0 || (seen ^ invert)==0 ) return 0;
|
| + }else{
|
| + if( c!=(*(z++)) ) return 0;
|
| + }
|
| + }
|
| + return *z==0;
|
| +}
|
| +
|
| +
|
| +/* Find a quotaGroup given the filename.
|
| +**
|
| +** Return a pointer to the quotaGroup object. Return NULL if not found.
|
| +*/
|
| +static quotaGroup *quotaGroupFind(const char *zFilename){
|
| + quotaGroup *p;
|
| + for(p=gQuota.pGroup; p && quotaStrglob(p->zPattern, zFilename)==0;
|
| + p=p->pNext){}
|
| + return p;
|
| +}
|
| +
|
| +/* Translate an sqlite3_file* that is really a quotaConn* into
|
| +** the sqlite3_file* for the underlying original VFS.
|
| +*/
|
| +static sqlite3_file *quotaSubOpen(sqlite3_file *pConn){
|
| + quotaConn *p = (quotaConn*)pConn;
|
| + return (sqlite3_file*)&p[1];
|
| +}
|
| +
|
| +/************************* VFS Method Wrappers *****************************/
|
| +/*
|
| +** This is the xOpen method used for the "quota" VFS.
|
| +**
|
| +** Most of the work is done by the underlying original VFS. This method
|
| +** simply links the new file into the appropriate quota group if it is a
|
| +** file that needs to be tracked.
|
| +*/
|
| +static int quotaOpen(
|
| + sqlite3_vfs *pVfs, /* The quota VFS */
|
| + const char *zName, /* Name of file to be opened */
|
| + sqlite3_file *pConn, /* Fill in this file descriptor */
|
| + int flags, /* Flags to control the opening */
|
| + int *pOutFlags /* Flags showing results of opening */
|
| +){
|
| + int rc; /* Result code */
|
| + quotaConn *pQuotaOpen; /* The new quota file descriptor */
|
| + quotaFile *pFile; /* Corresponding quotaFile obj */
|
| + quotaGroup *pGroup; /* The group file belongs to */
|
| + sqlite3_file *pSubOpen; /* Real file descriptor */
|
| + sqlite3_vfs *pOrigVfs = gQuota.pOrigVfs; /* Real VFS */
|
| +
|
| + /* If the file is not a main database file or a WAL, then use the
|
| + ** normal xOpen method.
|
| + */
|
| + if( (flags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_WAL))==0 ){
|
| + return pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags);
|
| + }
|
| +
|
| + /* If the name of the file does not match any quota group, then
|
| + ** use the normal xOpen method.
|
| + */
|
| + quotaEnter();
|
| + pGroup = quotaGroupFind(zName);
|
| + if( pGroup==0 ){
|
| + rc = pOrigVfs->xOpen(pOrigVfs, zName, pConn, flags, pOutFlags);
|
| + }else{
|
| + /* If we get to this point, it means the file needs to be quota tracked.
|
| + */
|
| + pQuotaOpen = (quotaConn*)pConn;
|
| + pSubOpen = quotaSubOpen(pConn);
|
| + rc = pOrigVfs->xOpen(pOrigVfs, zName, pSubOpen, flags, pOutFlags);
|
| + if( rc==SQLITE_OK ){
|
| + for(pFile=pGroup->pFiles; pFile && strcmp(pFile->zFilename, zName);
|
| + pFile=pFile->pNext){}
|
| + if( pFile==0 ){
|
| + int nName = strlen(zName);
|
| + pFile = sqlite3_malloc( sizeof(*pFile) + nName + 1 );
|
| + if( pFile==0 ){
|
| + quotaLeave();
|
| + pSubOpen->pMethods->xClose(pSubOpen);
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memset(pFile, 0, sizeof(*pFile));
|
| + pFile->zFilename = (char*)&pFile[1];
|
| + memcpy(pFile->zFilename, zName, nName+1);
|
| + pFile->pNext = pGroup->pFiles;
|
| + if( pGroup->pFiles ) pGroup->pFiles->ppPrev = &pFile->pNext;
|
| + pFile->ppPrev = &pGroup->pFiles;
|
| + pGroup->pFiles = pFile;
|
| + pFile->pGroup = pGroup;
|
| + }
|
| + pFile->nRef++;
|
| + pQuotaOpen->pFile = pFile;
|
| + if( pSubOpen->pMethods->iVersion==1 ){
|
| + pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV1;
|
| + }else{
|
| + pQuotaOpen->base.pMethods = &gQuota.sIoMethodsV2;
|
| + }
|
| + }
|
| + }
|
| + quotaLeave();
|
| + return rc;
|
| +}
|
| +
|
| +/************************ I/O Method Wrappers *******************************/
|
| +
|
| +/* xClose requests get passed through to the original VFS. But we
|
| +** also have to unlink the quotaConn from the quotaFile and quotaGroup.
|
| +** The quotaFile and/or quotaGroup are freed if they are no longer in use.
|
| +*/
|
| +static int quotaClose(sqlite3_file *pConn){
|
| + quotaConn *p = (quotaConn*)pConn;
|
| + quotaFile *pFile = p->pFile;
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + int rc;
|
| + rc = pSubOpen->pMethods->xClose(pSubOpen);
|
| + quotaEnter();
|
| + pFile->nRef--;
|
| + if( pFile->nRef==0 ){
|
| + quotaGroup *pGroup = pFile->pGroup;
|
| + pGroup->iSize -= pFile->iSize;
|
| + if( pFile->pNext ) pFile->pNext->ppPrev = pFile->ppPrev;
|
| + *pFile->ppPrev = pFile->pNext;
|
| + quotaGroupDeref(pGroup);
|
| + sqlite3_free(pFile);
|
| + }
|
| + quotaLeave();
|
| + return rc;
|
| +}
|
| +
|
| +/* Pass xRead requests directory thru to the original VFS without
|
| +** further processing.
|
| +*/
|
| +static int quotaRead(
|
| + sqlite3_file *pConn,
|
| + void *pBuf,
|
| + int iAmt,
|
| + sqlite3_int64 iOfst
|
| +){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
|
| +}
|
| +
|
| +/* Check xWrite requests to see if they expand the file. If they do,
|
| +** the perform a quota check before passing them through to the
|
| +** original VFS.
|
| +*/
|
| +static int quotaWrite(
|
| + sqlite3_file *pConn,
|
| + const void *pBuf,
|
| + int iAmt,
|
| + sqlite3_int64 iOfst
|
| +){
|
| + quotaConn *p = (quotaConn*)pConn;
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + sqlite3_int64 iEnd = iOfst+iAmt;
|
| + quotaGroup *pGroup;
|
| + quotaFile *pFile = p->pFile;
|
| + sqlite3_int64 szNew;
|
| +
|
| + if( pFile->iSize<iEnd ){
|
| + pGroup = pFile->pGroup;
|
| + quotaEnter();
|
| + szNew = pGroup->iSize - pFile->iSize + iEnd;
|
| + if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
|
| + if( pGroup->xCallback ){
|
| + pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
|
| + pGroup->pArg);
|
| + }
|
| + if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
|
| + quotaLeave();
|
| + return SQLITE_FULL;
|
| + }
|
| + }
|
| + pGroup->iSize = szNew;
|
| + pFile->iSize = iEnd;
|
| + quotaLeave();
|
| + }
|
| + return pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
|
| +}
|
| +
|
| +/* Pass xTruncate requests thru to the original VFS. If the
|
| +** success, update the file size.
|
| +*/
|
| +static int quotaTruncate(sqlite3_file *pConn, sqlite3_int64 size){
|
| + quotaConn *p = (quotaConn*)pConn;
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + int rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
|
| + quotaFile *pFile = p->pFile;
|
| + quotaGroup *pGroup;
|
| + if( rc==SQLITE_OK ){
|
| + quotaEnter();
|
| + pGroup = pFile->pGroup;
|
| + pGroup->iSize -= pFile->iSize;
|
| + pFile->iSize = size;
|
| + pGroup->iSize += size;
|
| + quotaLeave();
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/* Pass xSync requests through to the original VFS without change
|
| +*/
|
| +static int quotaSync(sqlite3_file *pConn, int flags){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xSync(pSubOpen, flags);
|
| +}
|
| +
|
| +/* Pass xFileSize requests through to the original VFS but then
|
| +** update the quotaGroup with the new size before returning.
|
| +*/
|
| +static int quotaFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
|
| + quotaConn *p = (quotaConn*)pConn;
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + quotaFile *pFile = p->pFile;
|
| + quotaGroup *pGroup;
|
| + sqlite3_int64 sz;
|
| + int rc;
|
| +
|
| + rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
|
| + if( rc==SQLITE_OK ){
|
| + quotaEnter();
|
| + pGroup = pFile->pGroup;
|
| + pGroup->iSize -= pFile->iSize;
|
| + pFile->iSize = sz;
|
| + pGroup->iSize += sz;
|
| + quotaLeave();
|
| + *pSize = sz;
|
| + }
|
| + return rc;
|
| +}
|
| +
|
| +/* Pass xLock requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaLock(sqlite3_file *pConn, int lock){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xLock(pSubOpen, lock);
|
| +}
|
| +
|
| +/* Pass xUnlock requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaUnlock(sqlite3_file *pConn, int lock){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xUnlock(pSubOpen, lock);
|
| +}
|
| +
|
| +/* Pass xCheckReservedLock requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaCheckReservedLock(sqlite3_file *pConn, int *pResOut){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut);
|
| +}
|
| +
|
| +/* Pass xFileControl requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaFileControl(sqlite3_file *pConn, int op, void *pArg){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
|
| +}
|
| +
|
| +/* Pass xSectorSize requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaSectorSize(sqlite3_file *pConn){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xSectorSize(pSubOpen);
|
| +}
|
| +
|
| +/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaDeviceCharacteristics(sqlite3_file *pConn){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen);
|
| +}
|
| +
|
| +/* Pass xShmMap requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaShmMap(
|
| + sqlite3_file *pConn, /* Handle open on database file */
|
| + int iRegion, /* Region to retrieve */
|
| + int szRegion, /* Size of regions */
|
| + int bExtend, /* True to extend file if necessary */
|
| + void volatile **pp /* OUT: Mapped memory */
|
| +){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend, pp);
|
| +}
|
| +
|
| +/* Pass xShmLock requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaShmLock(
|
| + sqlite3_file *pConn, /* Database file holding the shared memory */
|
| + int ofst, /* First lock to acquire or release */
|
| + int n, /* Number of locks to acquire or release */
|
| + int flags /* What to do with the lock */
|
| +){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
|
| +}
|
| +
|
| +/* Pass xShmBarrier requests through to the original VFS unchanged.
|
| +*/
|
| +static void quotaShmBarrier(sqlite3_file *pConn){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + pSubOpen->pMethods->xShmBarrier(pSubOpen);
|
| +}
|
| +
|
| +/* Pass xShmUnmap requests through to the original VFS unchanged.
|
| +*/
|
| +static int quotaShmUnmap(sqlite3_file *pConn, int deleteFlag){
|
| + sqlite3_file *pSubOpen = quotaSubOpen(pConn);
|
| + return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
|
| +}
|
| +
|
| +/************************** Public Interfaces *****************************/
|
| +/*
|
| +** Initialize the quota VFS shim. Use the VFS named zOrigVfsName
|
| +** as the VFS that does the actual work. Use the default if
|
| +** zOrigVfsName==NULL.
|
| +**
|
| +** The quota VFS shim is named "quota". It will become the default
|
| +** VFS if makeDefault is non-zero.
|
| +**
|
| +** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
|
| +** during start-up.
|
| +*/
|
| +int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
|
| + sqlite3_vfs *pOrigVfs;
|
| + if( gQuota.isInitialized ) return SQLITE_MISUSE;
|
| + pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
|
| + if( pOrigVfs==0 ) return SQLITE_ERROR;
|
| + assert( pOrigVfs!=&gQuota.sThisVfs );
|
| + gQuota.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
|
| + if( !gQuota.pMutex ){
|
| + return SQLITE_NOMEM;
|
| + }
|
| + gQuota.isInitialized = 1;
|
| + gQuota.pOrigVfs = pOrigVfs;
|
| + gQuota.sThisVfs = *pOrigVfs;
|
| + gQuota.sThisVfs.xOpen = quotaOpen;
|
| + gQuota.sThisVfs.szOsFile += sizeof(quotaConn);
|
| + gQuota.sThisVfs.zName = "quota";
|
| + gQuota.sIoMethodsV1.iVersion = 1;
|
| + gQuota.sIoMethodsV1.xClose = quotaClose;
|
| + gQuota.sIoMethodsV1.xRead = quotaRead;
|
| + gQuota.sIoMethodsV1.xWrite = quotaWrite;
|
| + gQuota.sIoMethodsV1.xTruncate = quotaTruncate;
|
| + gQuota.sIoMethodsV1.xSync = quotaSync;
|
| + gQuota.sIoMethodsV1.xFileSize = quotaFileSize;
|
| + gQuota.sIoMethodsV1.xLock = quotaLock;
|
| + gQuota.sIoMethodsV1.xUnlock = quotaUnlock;
|
| + gQuota.sIoMethodsV1.xCheckReservedLock = quotaCheckReservedLock;
|
| + gQuota.sIoMethodsV1.xFileControl = quotaFileControl;
|
| + gQuota.sIoMethodsV1.xSectorSize = quotaSectorSize;
|
| + gQuota.sIoMethodsV1.xDeviceCharacteristics = quotaDeviceCharacteristics;
|
| + gQuota.sIoMethodsV2 = gQuota.sIoMethodsV1;
|
| + gQuota.sIoMethodsV2.iVersion = 2;
|
| + gQuota.sIoMethodsV2.xShmMap = quotaShmMap;
|
| + gQuota.sIoMethodsV2.xShmLock = quotaShmLock;
|
| + gQuota.sIoMethodsV2.xShmBarrier = quotaShmBarrier;
|
| + gQuota.sIoMethodsV2.xShmUnmap = quotaShmUnmap;
|
| + sqlite3_vfs_register(&gQuota.sThisVfs, makeDefault);
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Shutdown the quota system.
|
| +**
|
| +** All SQLite database connections must be closed before calling this
|
| +** routine.
|
| +**
|
| +** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly one while
|
| +** shutting down in order to free all remaining quota groups.
|
| +*/
|
| +int sqlite3_quota_shutdown(void){
|
| + quotaGroup *pGroup;
|
| + if( gQuota.isInitialized==0 ) return SQLITE_MISUSE;
|
| + for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){
|
| + if( pGroup->pFiles ) return SQLITE_MISUSE;
|
| + }
|
| + while( gQuota.pGroup ){
|
| + pGroup = gQuota.pGroup;
|
| + gQuota.pGroup = pGroup->pNext;
|
| + pGroup->iLimit = 0;
|
| + quotaGroupDeref(pGroup);
|
| + }
|
| + gQuota.isInitialized = 0;
|
| + sqlite3_mutex_free(gQuota.pMutex);
|
| + sqlite3_vfs_unregister(&gQuota.sThisVfs);
|
| + memset(&gQuota, 0, sizeof(gQuota));
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +/*
|
| +** Create or destroy a quota group.
|
| +**
|
| +** The quota group is defined by the zPattern. When calling this routine
|
| +** with a zPattern for a quota group that already exists, this routine
|
| +** merely updates the iLimit, xCallback, and pArg values for that quota
|
| +** group. If zPattern is new, then a new quota group is created.
|
| +**
|
| +** If the iLimit for a quota group is set to zero, then the quota group
|
| +** is disabled and will be deleted when the last database connection using
|
| +** the quota group is closed.
|
| +**
|
| +** Calling this routine on a zPattern that does not exist and with a
|
| +** zero iLimit is a no-op.
|
| +**
|
| +** A quota group must exist with a non-zero iLimit prior to opening
|
| +** database connections if those connections are to participate in the
|
| +** quota group. Creating a quota group does not affect database connections
|
| +** that are already open.
|
| +*/
|
| +int sqlite3_quota_set(
|
| + const char *zPattern, /* The filename pattern */
|
| + sqlite3_int64 iLimit, /* New quota to set for this quota group */
|
| + void (*xCallback)( /* Callback invoked when going over quota */
|
| + const char *zFilename, /* Name of file whose size increases */
|
| + sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
| + sqlite3_int64 iSize, /* Total size of all files in the group */
|
| + void *pArg /* Client data */
|
| + ),
|
| + void *pArg, /* client data passed thru to callback */
|
| + void (*xDestroy)(void*) /* Optional destructor for pArg */
|
| +){
|
| + quotaGroup *pGroup;
|
| + quotaEnter();
|
| + pGroup = gQuota.pGroup;
|
| + while( pGroup && strcmp(pGroup->zPattern, zPattern)!=0 ){
|
| + pGroup = pGroup->pNext;
|
| + }
|
| + if( pGroup==0 ){
|
| + int nPattern = strlen(zPattern);
|
| + if( iLimit<=0 ){
|
| + quotaLeave();
|
| + return SQLITE_OK;
|
| + }
|
| + pGroup = sqlite3_malloc( sizeof(*pGroup) + nPattern + 1 );
|
| + if( pGroup==0 ){
|
| + quotaLeave();
|
| + return SQLITE_NOMEM;
|
| + }
|
| + memset(pGroup, 0, sizeof(*pGroup));
|
| + pGroup->zPattern = (char*)&pGroup[1];
|
| + memcpy((char *)pGroup->zPattern, zPattern, nPattern+1);
|
| + if( gQuota.pGroup ) gQuota.pGroup->ppPrev = &pGroup->pNext;
|
| + pGroup->pNext = gQuota.pGroup;
|
| + pGroup->ppPrev = &gQuota.pGroup;
|
| + gQuota.pGroup = pGroup;
|
| + }
|
| + pGroup->iLimit = iLimit;
|
| + pGroup->xCallback = xCallback;
|
| + if( pGroup->xDestroy && pGroup->pArg!=pArg ){
|
| + pGroup->xDestroy(pGroup->pArg);
|
| + }
|
| + pGroup->pArg = pArg;
|
| + pGroup->xDestroy = xDestroy;
|
| + quotaGroupDeref(pGroup);
|
| + quotaLeave();
|
| + return SQLITE_OK;
|
| +}
|
| +
|
| +
|
| +/***************************** Test Code ***********************************/
|
| +#ifdef SQLITE_TEST
|
| +#include <tcl.h>
|
| +
|
| +/*
|
| +** Argument passed to a TCL quota-over-limit callback.
|
| +*/
|
| +typedef struct TclQuotaCallback TclQuotaCallback;
|
| +struct TclQuotaCallback {
|
| + Tcl_Interp *interp; /* Interpreter in which to run the script */
|
| + Tcl_Obj *pScript; /* Script to be run */
|
| +};
|
| +
|
| +extern const char *sqlite3TestErrorName(int);
|
| +
|
| +
|
| +/*
|
| +** This is the callback from a quota-over-limit.
|
| +*/
|
| +static void tclQuotaCallback(
|
| + const char *zFilename, /* Name of file whose size increases */
|
| + sqlite3_int64 *piLimit, /* IN/OUT: The current limit */
|
| + sqlite3_int64 iSize, /* Total size of all files in the group */
|
| + void *pArg /* Client data */
|
| +){
|
| + TclQuotaCallback *p; /* Callback script object */
|
| + Tcl_Obj *pEval; /* Script to evaluate */
|
| + Tcl_Obj *pVarname; /* Name of variable to pass as 2nd arg */
|
| + unsigned int rnd; /* Random part of pVarname */
|
| + int rc; /* Tcl error code */
|
| +
|
| + p = (TclQuotaCallback *)pArg;
|
| + if( p==0 ) return;
|
| +
|
| + pVarname = Tcl_NewStringObj("::piLimit_", -1);
|
| + Tcl_IncrRefCount(pVarname);
|
| + sqlite3_randomness(sizeof(rnd), (void *)&rnd);
|
| + Tcl_AppendObjToObj(pVarname, Tcl_NewIntObj((int)(rnd&0x7FFFFFFF)));
|
| + Tcl_ObjSetVar2(p->interp, pVarname, 0, Tcl_NewWideIntObj(*piLimit), 0);
|
| +
|
| + pEval = Tcl_DuplicateObj(p->pScript);
|
| + Tcl_IncrRefCount(pEval);
|
| + Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zFilename, -1));
|
| + Tcl_ListObjAppendElement(0, pEval, pVarname);
|
| + Tcl_ListObjAppendElement(0, pEval, Tcl_NewWideIntObj(iSize));
|
| + rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
|
| +
|
| + if( rc==TCL_OK ){
|
| + Tcl_Obj *pLimit = Tcl_ObjGetVar2(p->interp, pVarname, 0, 0);
|
| + rc = Tcl_GetWideIntFromObj(p->interp, pLimit, piLimit);
|
| + Tcl_UnsetVar(p->interp, Tcl_GetString(pVarname), 0);
|
| + }
|
| +
|
| + Tcl_DecrRefCount(pEval);
|
| + Tcl_DecrRefCount(pVarname);
|
| + if( rc!=TCL_OK ) Tcl_BackgroundError(p->interp);
|
| +}
|
| +
|
| +/*
|
| +** Destructor for a TCL quota-over-limit callback.
|
| +*/
|
| +static void tclCallbackDestructor(void *pObj){
|
| + TclQuotaCallback *p = (TclQuotaCallback*)pObj;
|
| + if( p ){
|
| + Tcl_DecrRefCount(p->pScript);
|
| + sqlite3_free((char *)p);
|
| + }
|
| +}
|
| +
|
| +/*
|
| +** tclcmd: sqlite3_quota_initialize NAME MAKEDEFAULT
|
| +*/
|
| +static int test_quota_initialize(
|
| + void * clientData,
|
| + Tcl_Interp *interp,
|
| + int objc,
|
| + Tcl_Obj *CONST objv[]
|
| +){
|
| + const char *zName; /* Name of new quota VFS */
|
| + int makeDefault; /* True to make the new VFS the default */
|
| + int rc; /* Value returned by quota_initialize() */
|
| +
|
| + /* Process arguments */
|
| + if( objc!=3 ){
|
| + Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
|
| + return TCL_ERROR;
|
| + }
|
| + zName = Tcl_GetString(objv[1]);
|
| + if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
|
| + if( zName[0]=='\0' ) zName = 0;
|
| +
|
| + /* Call sqlite3_quota_initialize() */
|
| + rc = sqlite3_quota_initialize(zName, makeDefault);
|
| + Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
| +
|
| + return TCL_OK;
|
| +}
|
| +
|
| +/*
|
| +** tclcmd: sqlite3_quota_shutdown
|
| +*/
|
| +static int test_quota_shutdown(
|
| + void * clientData,
|
| + Tcl_Interp *interp,
|
| + int objc,
|
| + Tcl_Obj *CONST objv[]
|
| +){
|
| + int rc; /* Value returned by quota_shutdown() */
|
| +
|
| + if( objc!=1 ){
|
| + Tcl_WrongNumArgs(interp, 1, objv, "");
|
| + return TCL_ERROR;
|
| + }
|
| +
|
| + /* Call sqlite3_quota_shutdown() */
|
| + rc = sqlite3_quota_shutdown();
|
| + Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
| +
|
| + return TCL_OK;
|
| +}
|
| +
|
| +/*
|
| +** tclcmd: sqlite3_quota_set PATTERN LIMIT SCRIPT
|
| +*/
|
| +static int test_quota_set(
|
| + void * clientData,
|
| + Tcl_Interp *interp,
|
| + int objc,
|
| + Tcl_Obj *CONST objv[]
|
| +){
|
| + const char *zPattern; /* File pattern to configure */
|
| + sqlite3_int64 iLimit; /* Initial quota in bytes */
|
| + Tcl_Obj *pScript; /* Tcl script to invoke to increase quota */
|
| + int rc; /* Value returned by quota_set() */
|
| + TclQuotaCallback *p; /* Callback object */
|
| + int nScript; /* Length of callback script */
|
| + void (*xDestroy)(void*); /* Optional destructor for pArg */
|
| + void (*xCallback)(const char *, sqlite3_int64 *, sqlite3_int64, void *);
|
| +
|
| + /* Process arguments */
|
| + if( objc!=4 ){
|
| + Tcl_WrongNumArgs(interp, 1, objv, "PATTERN LIMIT SCRIPT");
|
| + return TCL_ERROR;
|
| + }
|
| + zPattern = Tcl_GetString(objv[1]);
|
| + if( Tcl_GetWideIntFromObj(interp, objv[2], &iLimit) ) return TCL_ERROR;
|
| + pScript = objv[3];
|
| + Tcl_GetStringFromObj(pScript, &nScript);
|
| +
|
| + if( nScript>0 ){
|
| + /* Allocate a TclQuotaCallback object */
|
| + p = (TclQuotaCallback *)sqlite3_malloc(sizeof(TclQuotaCallback));
|
| + if( !p ){
|
| + Tcl_SetResult(interp, (char *)"SQLITE_NOMEM", TCL_STATIC);
|
| + return TCL_OK;
|
| + }
|
| + memset(p, 0, sizeof(TclQuotaCallback));
|
| + p->interp = interp;
|
| + Tcl_IncrRefCount(pScript);
|
| + p->pScript = pScript;
|
| + xDestroy = tclCallbackDestructor;
|
| + xCallback = tclQuotaCallback;
|
| + }else{
|
| + p = 0;
|
| + xDestroy = 0;
|
| + xCallback = 0;
|
| + }
|
| +
|
| + /* Invoke sqlite3_quota_set() */
|
| + rc = sqlite3_quota_set(zPattern, iLimit, xCallback, (void*)p, xDestroy);
|
| +
|
| + Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
|
| + return TCL_OK;
|
| +}
|
| +
|
| +/*
|
| +** tclcmd: sqlite3_quota_dump
|
| +*/
|
| +static int test_quota_dump(
|
| + void * clientData,
|
| + Tcl_Interp *interp,
|
| + int objc,
|
| + Tcl_Obj *CONST objv[]
|
| +){
|
| + Tcl_Obj *pResult;
|
| + Tcl_Obj *pGroupTerm;
|
| + Tcl_Obj *pFileTerm;
|
| + quotaGroup *pGroup;
|
| + quotaFile *pFile;
|
| +
|
| + pResult = Tcl_NewObj();
|
| + quotaEnter();
|
| + for(pGroup=gQuota.pGroup; pGroup; pGroup=pGroup->pNext){
|
| + pGroupTerm = Tcl_NewObj();
|
| + Tcl_ListObjAppendElement(interp, pGroupTerm,
|
| + Tcl_NewStringObj(pGroup->zPattern, -1));
|
| + Tcl_ListObjAppendElement(interp, pGroupTerm,
|
| + Tcl_NewWideIntObj(pGroup->iLimit));
|
| + Tcl_ListObjAppendElement(interp, pGroupTerm,
|
| + Tcl_NewWideIntObj(pGroup->iSize));
|
| + for(pFile=pGroup->pFiles; pFile; pFile=pFile->pNext){
|
| + pFileTerm = Tcl_NewObj();
|
| + Tcl_ListObjAppendElement(interp, pFileTerm,
|
| + Tcl_NewStringObj(pFile->zFilename, -1));
|
| + Tcl_ListObjAppendElement(interp, pFileTerm,
|
| + Tcl_NewWideIntObj(pFile->iSize));
|
| + Tcl_ListObjAppendElement(interp, pFileTerm,
|
| + Tcl_NewWideIntObj(pFile->nRef));
|
| + Tcl_ListObjAppendElement(interp, pGroupTerm, pFileTerm);
|
| + }
|
| + Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
|
| + }
|
| + quotaLeave();
|
| + Tcl_SetObjResult(interp, pResult);
|
| + return TCL_OK;
|
| +}
|
| +
|
| +/*
|
| +** This routine registers the custom TCL commands defined in this
|
| +** module. This should be the only procedure visible from outside
|
| +** of this module.
|
| +*/
|
| +int Sqlitequota_Init(Tcl_Interp *interp){
|
| + static struct {
|
| + char *zName;
|
| + Tcl_ObjCmdProc *xProc;
|
| + } aCmd[] = {
|
| + { "sqlite3_quota_initialize", test_quota_initialize },
|
| + { "sqlite3_quota_shutdown", test_quota_shutdown },
|
| + { "sqlite3_quota_set", test_quota_set },
|
| + { "sqlite3_quota_dump", test_quota_dump },
|
| + };
|
| + int i;
|
| +
|
| + for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
|
| + Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
|
| + }
|
| +
|
| + return TCL_OK;
|
| +}
|
| +#endif
|
|
|
Chromium Code Reviews
