database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-08 14:02:16 +03:00
Code Activity

Merge the test_quota.c module into the trunk.

Browse Source 
FossilOrigin-Name: 2e1a02026a0635fe05ba55a6d4d36dd7fd0ae8e9
This commit is contained in:
drh
2010-09-01 15:22:56 +00:00
parent 748a52cdcb 3d3e60e481
commit 6e19e91e84
6 changed files with 688 additions and 177 deletions
Download Patch File Download Diff File Expand all files Collapse all files

623
src/test_quota.c
View File

@@ -17,8 +17,8 @@
** 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 met or exceeded, then new
** write requests that attempt to enlarge a file fail with SQLITE_FULL.
** of all files in the quota group is greater than or equal to 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.
@@ -28,22 +28,30 @@
** continues as if nothing had happened.
*/
#include "sqlite3.h"
#include <string.h>
#include <assert.h>
/************************ Object Definitions ******************************/
/*
** This module contains a table of filename patterns that have size
** quotas. The quota applies to the sum of the sizes of all open
** database files whose names match the GLOB pattern.
**
** Each quota is an instance of the following object. Quotas must
** be established (using sqlite3_quota_set()) prior to opening any
** of the database connections that access files governed by the
** quota.
**
** Each entry in the quota table is an instance of the following object.
*/
/* 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 */
@@ -55,20 +63,36 @@ struct quotaGroup {
void *pArg /* Client data */
);
void *pArg; /* Third argument to the xCallback() */
int nRef; /* Number of files in the group references. */
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 the following object represents each file that
** participates in quota tracking. The sqlite3_file object for the
** underlying VFS is appended to this structure.
** 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.
*/
typedef struct quotaFile quotaFile;
struct quotaFile {
sqlite3_file base; /* Base class - must be first */
const char *zFilename; /* Name of this file */
quotaGroup *pGroup; /* Upper bound on file size */
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 */
};
@@ -78,7 +102,7 @@ struct quotaFile {
** gQuota structure.
*/
static struct {
/* The pOrigVfs is a pointer to the real underlying VFS implementation.
/* 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.
@@ -130,11 +154,12 @@ 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(quotaFile *p){
if( p->nRef==0 && p->iLimit==0 ){
if( p->pNext ) p->pNext->ppPrev = p->ppPrev;
if( p->ppPrev ) *p->ppPrev = p->pNext;
sqlite3_free(p);
static void quotaGroupDeref(quotaGroup *pGroup){
if( pGroup->pFiles==0 && pGroup->iLimit==0 ){
if( pGroup->pNext ) pGroup->pNext->ppPrev = pGroup->ppPrev;
if( pGroup->ppPrev ) *pGroup->ppPrev = pGroup->pNext;
if( pGroup->xDestroy ) pGroup->xDestroy(pGroup->pArg);
sqlite3_free(pGroup);
}
}
@@ -153,7 +178,7 @@ static void quotaGroupDeref(quotaFile *p){
** [^...] Matches one character not in the enclosed list.
**
*/
static int strglob(const char *zGlob, const char *z){
static int quotaStrglob(const char *zGlob, const char *z){
int c, c2;
int invert;
int seen;
@@ -166,7 +191,7 @@ static int strglob(const char *zGlob, const char *z){
if( c==0 ){
return 1;
}else if( c=='[' ){
while( *z && th3strglob(zGlob-1,z)==0 ){
while( *z && quotaStrglob(zGlob-1,z)==0 ){
z++;
}
return (*z)!=0;
@@ -176,7 +201,7 @@ static int strglob(const char *zGlob, const char *z){
c2 = *(z++);
if( c2==0 ) return 0;
}
if( th3strglob(zGlob,z) ) return 1;
if( quotaStrglob(zGlob,z) ) return 1;
}
return 0;
}else if( c=='?' ){
@@ -219,19 +244,21 @@ static int strglob(const char *zGlob, const char *z){
/* Find a quotaGroup given the filename.
** Return a pointer to the quotaFile object. return NULL if not found.
**
** Return a pointer to the quotaGroup object. Return NULL if not found.
*/
static quotaGroup *quotaGroupFind(const char *zFilename){
quotaGroup *p;
for(p=pGroup; p && strglob(p->zPattern, zFilename)==0; p=p->pNext){}
for(p=gQuota.pGroup; p && quotaStrglob(p->zPattern, zFilename)==0;
p=p->pNext){}
return p;
}
/* Translate an sqlite3_file* that is really a quotaFile* into
** an sqlite3_file* for the underlying original VFS.
/* Translate an sqlite3_file* that is really a quotaConn* into
** the sqlite3_file* for the underlying original VFS.
*/
static sqlite3_file *quotaSubFile(sqlite3_file *pFile){
quotaFile *p = (quotaFile*)pFile;
static sqlite3_file *quotaSubOpen(sqlite3_file *pConn){
quotaConn *p = (quotaConn*)pConn;
return (sqlite3_file*)&p[1];
}
@@ -240,75 +267,98 @@ static sqlite3_file *quotaSubFile(sqlite3_file *pFile){
** 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 quota group if it is a file that
** needs to be tracked.
** 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,
const char *zName,
sqlite3_file *pFile,
int flags,
int *pOutFlags
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;
quotaFile *pQuotaFile;
sqlite3_file *pSubFile;
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_MAIN_WAL))==0 ){
return gQuota.pOrigVfs->xOpen(gQuota.pOrigVfs, zName,
pFile, flags, pOutFlags);
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 = quotaFindGroup(zName);
pGroup = quotaGroupFind(zName);
if( pGroup==0 ){
return gQuota.pOrigVfs->xOpen(gQuota.pOrigVfs, zName,
pFile, flags, pOutFlags);
}
/* If we get to this point, it means the file needs
** to be quota tracked.
*/
pQuotaFile = (quotaFile*)pFile;
pSubFile = quotaSubFile(pFile);
rc = gQuota.pOrigVfs->xOpen(gQuota.pOrigVfs, zName,
pSubFile, flags, pOutFlags);
if( rc==SQLITE_OK ){
pQuotaFile->iSize = 0;
pQuotaFile->pGroup = pGroup;
pGroup->nRef++;
quotaLeave();
pQuotaFile->zFilename = zName;
if( pSubFile->pMethods.iVersion==1 ){
pQuotaFile->base.pMethods = &gQuota.sIoMethodsV1;
}else{
pQuotaFile->base.pMethods = &gQuota.sIoMethodsV2;
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 quotaFile from the quotaGroup.
** 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 *pFile){
quotaFile *p = (quotaFile*)pFile;
quotaGroup *pGroup = p->pGroup;
sqlite3_file *pSubFile = quotaSubFile(pFile);
static int quotaClose(sqlite3_file *pConn){
quotaConn *p = (quotaConn*)pConn;
quotaFile *pFile = p->pFile;
sqlite3_file *pSubOpen = quotaSubOpen(pConn);
int rc;
rc = pSubFile->pMethods.xClose(pSubFile);
rc = pSubOpen->pMethods->xClose(pSubOpen);
quotaEnter();
pGroup->nRef--;
pGroup->iSize -= p->iSize;
quotaGroupDeref(pGroup);
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;
}
@@ -317,13 +367,13 @@ static int quotaClose(sqlite3_file *pFile){
** further processing.
*/
static int quotaRead(
sqlite3_file *pFile,
sqlite3_file *pConn,
void *pBuf,
int iAmt,
sqlite3_int64 iOfst
){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xRead(pSubFile, pBuf, iAmt, 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,
@@ -331,49 +381,53 @@ static int quotaRead(
** original VFS.
*/
static int quotaWrite(
sqlite3_file *pFile,
void *pBuf,
sqlite3_file *pConn,
const void *pBuf,
int iAmt,
sqlite3_int64 iOfst
){
quotaFile *p = (quotaFile*)pFile;
sqlite3_file *pSubFile = quotaSubFile(pFile);
quotaConn *p = (quotaConn*)pConn;
sqlite3_file *pSubOpen = quotaSubOpen(pConn);
sqlite3_int64 iEnd = iOfst+iAmt;
quotaGroup *pGroup;
quotaFile *pFile = p->pFile;
sqlite3_int64 szNew;
if( p->iSize<iEnd ){
pGroup = p->pGroup;
if( pFile->iSize<iEnd ){
pGroup = pFile->pGroup;
quotaEnter();
szNew = pGroup->iSize - p->iSize + iEnd;
if( szNew >= pGroup->iLimit && pGroup->iLimit > 0 ){
szNew = pGroup->iSize - pFile->iSize + iEnd;
if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
if( pGroup->xCallback ){
pGroup->xCallback(p->zFilename, &pGroup->iLimit, szNew,
pGroup->xCallback(pFile->zFilename, &pGroup->iLimit, szNew,
pGroup->pArg);
}
if( szNew >= pGroup->iLimit && pGroup->iLimit > 0 ){
if( szNew>pGroup->iLimit && pGroup->iLimit>0 ){
quotaLeave();
return SQLITE_FULL;
}
}
pGroup->iSize = szNew;
pFile->iSize = iEnd;
quotaLeave();
}
return pSubFile->pMethods.xWrite(pSubFile, pBuf, iAmt, iOfst);
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 *pFile, sqlite3_int64 size){
quotaFile *p = (quotaFile*)pFile);
sqlite3_file *pSubFile = quotaSubFile(pFile);
int rc = pSubFile->pMethods.xTruncate(pSubFile, size);
quotaGroup *pGroup = p->pGroup;
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->iSize -= p->iSize;
p->iSize = size;
pGroup = pFile->pGroup;
pGroup->iSize -= pFile->iSize;
pFile->iSize = size;
pGroup->iSize += size;
quotaLeave();
}
@@ -382,27 +436,28 @@ static int quotaTruncate(sqlite3_file *pFile, sqlite3_int64 size){
/* Pass xSync requests through to the original VFS without change
*/
static int quotaSync(sqlite3_file *pFile, int flags){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xSync(pSubFile, flags);
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 *pFile, sqlite3_int64 *pSize){
quotaFile *p = (quotaFile*)pFile;
sqlite3_file *pSubFile = quotaSubFile(pFile);
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 = pSubFile->pMethods.xFileSize(pSubFile, &sz);
rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
if( rc==SQLITE_OK ){
pGroup = p->pGroup;
quotaEnter();
pGroup->iSize -= p->iSize;
p->iSize = sz;
pGroup = pFile->pGroup;
pGroup->iSize -= pFile->iSize;
pFile->iSize = sz;
pGroup->iSize += sz;
quotaLeave();
*pSize = sz;
@@ -412,83 +467,83 @@ static int quotaFileSize(sqlite3_file *pFile, sqlite3_int64 *pSize){
/* Pass xLock requests through to the original VFS unchanged.
*/
static int quotaLock(sqlite3_file *pFile, int lock){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xLock(pSubFile, lock);
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 *pFile, int lock){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xUnlock(pSubFile, lock);
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 *pFile, int *pResOut){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xCheckReservedLock(pSubFile, pResOut);
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 *pFile, int op, void *pArg){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xFileControl(pSubFile, op, pArg);
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 *pFile){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xSectorSize(pSubFile);
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 *pFile){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xDeviceCharacteristics(pSubFile);
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 *pFile, /* Handle open on database file */
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 *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xShmMap(pSubFile, iRegion, szRegion, bExtend, pp);
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 *pFile, /* Database file holding the shared memory */
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 *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xShmLock(pSubFile, ofst, n, flags);
sqlite3_file *pSubOpen = quotaSubOpen(pConn);
return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
}
/* Pass xShmBarrier requests through to the original VFS unchanged.
*/
static int quotaShmBarrier(sqlite3_file *pFile){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xShmBarrier(pSubFile);
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 *pFile, int deleteFlag){
sqlite3_file *pSubFile = quotaSubFile(pFile);
return pSubFile->pMethods.xShmUnmap(pSubFile, deleteFlag);
static int quotaShmUnmap(sqlite3_file *pConn, int deleteFlag){
sqlite3_file *pSubOpen = quotaSubOpen(pConn);
return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
}
/************************** Public Interfaces *****************************/
@@ -505,14 +560,19 @@ static int quotaShmUnmap(sqlite3_file *pFile, int deleteFlag){
*/
int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
sqlite3_vfs *pOrigVfs;
if( gQuota.isInitialize ) return SQLITE_MISUSE;
gQuota.isInitialized = 1;
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(quotaFile);
gQuota.sThisVfs.szOsFile += sizeof(quotaConn);
gQuota.sThisVfs.zName = "quota";
gQuota.sIoMethodsV1.iVersion = 1;
gQuota.sIoMethodsV1.xClose = quotaClose;
@@ -525,7 +585,7 @@ int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
gQuota.sIoMethodsV1.xUnlock = quotaUnlock;
gQuota.sIoMethodsV1.xCheckReservedLock = quotaCheckReservedLock;
gQuota.sIoMethodsV1.xFileControl = quotaFileControl;
gQuota.sIoMethodsV1.xSectorSize = quotaSectoSize;
gQuota.sIoMethodsV1.xSectorSize = quotaSectorSize;
gQuota.sIoMethodsV1.xDeviceCharacteristics = quotaDeviceCharacteristics;
gQuota.sIoMethodsV2 = gQuota.sIoMethodsV1;
gQuota.sIoMethodsV2.iVersion = 2;
@@ -533,7 +593,8 @@ int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
gQuota.sIoMethodsV2.xShmLock = quotaShmLock;
gQuota.sIoMethodsV2.xShmBarrier = quotaShmBarrier;
gQuota.sIoMethodsV2.xShmUnmap = quotaShmUnmap;
gQuota.pMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
sqlite3_vfs_register(&gQuota.sThisVfs, makeDefault);
return SQLITE_OK;
}
/*
@@ -546,16 +607,21 @@ int sqlite3_quota_initialize(const char *zOrigVfsName, int makeDefault){
** 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;
sqlite3_free(pGroup);
}
gQuota.isInitialized = 0;
sqlite3_mutex_free(gQuota.pMutex);
while( gQuota.pGroup ){
quotaGroup *p = gQuota.pGroup;
gQuota.pGroup = p->pNext;
if( p->nRef ) return SQLITE_MISUSE;
sqlite3_free(p);
}
sqlite3_vfs_unregister(&gQuota.sThisVfs);
memset(&gQuota, 0, sizeof(gQuota));
return SQLITE_OK;
}
/*
@@ -575,19 +641,20 @@ int sqlite3_quota_shutdown(void){
**
** 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 effect database connections
** 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 *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 *pArg, /* client data passed thru to callback */
void (*xDestroy)(void*) /* Optional destructor for pArg */
){
quotaGroup *pGroup;
quotaEnter();
@@ -595,8 +662,12 @@ int sqlite3_quota_set(
while( pGroup && strcmp(pGroup->zPattern, zPattern)!=0 ){
pGroup = pGroup->pNext;
}
if( pGroup==0 && iLimit>0 ){
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();
@@ -604,14 +675,19 @@ int sqlite3_quota_set(
}
memset(pGroup, 0, sizeof(*pGroup));
pGroup->zPattern = (char*)&pGroup[1];
memcpy(pGroup->zPattern, zPattern, nPattern+1);
pGroup->pNext = gQuota.pGroup;
memcpy((char *)pGroup->zPattern, zPattern, nPattern+1);
if( gQuota.pGroup ) gQuota.pGroup->ppPrev = &pGroup->pNext;
pGroup->ppPrev = &gQuota.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;
@@ -621,14 +697,231 @@ int sqlite3_quota_set(
/***************************** 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);
ckfree((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 */
/* 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 *)ckalloc(sizeof(TclQuotaCallback));
memset(p, 0, sizeof(TclQuotaCallback));
p->interp = interp;
Tcl_IncrRefCount(pScript);
p->pScript = pScript;
}else{
p = 0;
}
/* Invoke sqlite3_quota_set() */
rc = sqlite3_quota_set(zPattern, iLimit, tclQuotaCallback,
(void*)p, tclCallbackDestructor);
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){
#ifdef SQLITE_ENABLE_ASYNCIO
#endif /* SQLITE_ENABLE_ASYNCIO */
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