aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/alter.c28
-rw-r--r--src/analyze.c63
-rw-r--r--src/backup.c4
-rw-r--r--src/btree.c17
-rw-r--r--src/btree.h2
-rw-r--r--src/os_unix.c256
-rw-r--r--src/sqlite.h.in8
-rw-r--r--src/tclsqlite.c2
-rw-r--r--src/test1.c39
-rw-r--r--src/test_hexio.c7
-rw-r--r--src/test_multiplex.c560
-rw-r--r--src/test_multiplex.h91
-rw-r--r--src/test_syscall.c654
-rw-r--r--src/vdbeaux.c5
-rw-r--r--src/where.c2
15 files changed, 1386 insertions, 352 deletions
diff --git a/src/alter.c b/src/alter.c
index 1534fdf69..aa3fa929f 100644
--- a/src/alter.c
+++ b/src/alter.c
@@ -371,6 +371,22 @@ static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
}
/*
+** Parameter zName is the name of a table that is about to be altered
+** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
+** If the table is a system table, this function leaves an error message
+** in pParse->zErr (system tables may not be altered) and returns non-zero.
+**
+** Or, if zName is not a system table, zero is returned.
+*/
+static int isSystemTable(Parse *pParse, const char *zName){
+ if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
+ sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
+ return 1;
+ }
+ return 0;
+}
+
+/*
** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
** command.
*/
@@ -420,14 +436,11 @@ void sqlite3AlterRenameTable(
/* Make sure it is not a system table being altered, or a reserved name
** that the table is being renamed to.
*/
- if( sqlite3Strlen30(pTab->zName)>6
- && 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
- ){
- sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
+ if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
goto exit_rename_table;
}
- if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
- goto exit_rename_table;
+ if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
+ exit_rename_table;
}
#ifndef SQLITE_OMIT_VIEW
@@ -759,6 +772,9 @@ void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
goto exit_begin_add_column;
}
+ if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
+ goto exit_begin_add_column;
+ }
assert( pTab->addColOffset>0 );
iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
diff --git a/src/analyze.c b/src/analyze.c
index 0a8339baf..231d41431 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -34,7 +34,8 @@ static void openStatTable(
Parse *pParse, /* Parsing context */
int iDb, /* The database we are looking in */
int iStatCur, /* Open the sqlite_stat1 table on this cursor */
- const char *zWhere /* Delete entries associated with this table */
+ const char *zWhere, /* Delete entries for this table or index */
+ const char *zWhereType /* Either "tbl" or "idx" */
){
static const struct {
const char *zName;
@@ -79,7 +80,7 @@ static void openStatTable(
sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
if( zWhere ){
sqlite3NestedParse(pParse,
- "DELETE FROM %Q.%s WHERE tbl=%Q", pDb->zName, zTab, zWhere
+ "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere
);
}else{
/* The sqlite_stat[12] table already exists. Delete all rows. */
@@ -103,6 +104,7 @@ static void openStatTable(
static void analyzeOneTable(
Parse *pParse, /* Parser context */
Table *pTab, /* Table whose indices are to be analyzed */
+ Index *pOnlyIdx, /* If not NULL, only analyze this one index */
int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */
int iMem /* Available memory locations begin here */
){
@@ -113,8 +115,7 @@ static void analyzeOneTable(
int i; /* Loop counter */
int topOfLoop; /* The top of the loop */
int endOfLoop; /* The end of the loop */
- int addr = 0; /* The address of an instruction */
- int jZeroRows = 0; /* Jump from here if number of rows is zero */
+ int jZeroRows = -1; /* Jump from here if number of rows is zero */
int iDb; /* Index of database containing pTab */
int regTabname = iMem++; /* Register containing table name */
int regIdxname = iMem++; /* Register containing index name */
@@ -125,6 +126,7 @@ static void analyzeOneTable(
int regRowid = iMem++; /* Rowid for the inserted record */
#ifdef SQLITE_ENABLE_STAT2
+ int addr = 0; /* Instruction address */
int regTemp2 = iMem++; /* Temporary use register */
int regSamplerecno = iMem++; /* Index of next sample to record */
int regRecno = iMem++; /* Current sample index */
@@ -160,9 +162,12 @@ static void analyzeOneTable(
iIdxCur = pParse->nTab++;
sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
- int nCol = pIdx->nColumn;
- KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
+ int nCol;
+ KeyInfo *pKey;
+ if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
+ nCol = pIdx->nColumn;
+ pKey = sqlite3IndexKeyinfo(pParse, pIdx);
if( iMem+1+(nCol*2)>pParse->nMem ){
pParse->nMem = iMem+1+(nCol*2);
}
@@ -319,7 +324,7 @@ static void analyzeOneTable(
** is never possible.
*/
sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regSampleno);
- if( jZeroRows==0 ){
+ if( jZeroRows<0 ){
jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);
}
for(i=0; i<nCol; i++){
@@ -345,10 +350,10 @@ static void analyzeOneTable(
VdbeComment((v, "%s", pTab->zName));
sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regSampleno);
sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
+ jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regSampleno);
}else{
- assert( jZeroRows>0 );
- addr = sqlite3VdbeAddOp0(v, OP_Goto);
sqlite3VdbeJumpHere(v, jZeroRows);
+ jZeroRows = sqlite3VdbeAddOp0(v, OP_Goto);
}
sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);
@@ -356,9 +361,7 @@ static void analyzeOneTable(
sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regRowid);
sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
if( pParse->nMem<regRec ) pParse->nMem = regRec;
- if( jZeroRows ){
- sqlite3VdbeJumpHere(v, addr);
- }
+ sqlite3VdbeJumpHere(v, jZeroRows);
}
/*
@@ -385,20 +388,21 @@ static void analyzeDatabase(Parse *pParse, int iDb){
sqlite3BeginWriteOperation(pParse, 0, iDb);
iStatCur = pParse->nTab;
pParse->nTab += 2;
- openStatTable(pParse, iDb, iStatCur, 0);
+ openStatTable(pParse, iDb, iStatCur, 0, 0);
iMem = pParse->nMem+1;
for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
Table *pTab = (Table*)sqliteHashData(k);
- analyzeOneTable(pParse, pTab, iStatCur, iMem);
+ analyzeOneTable(pParse, pTab, 0, iStatCur, iMem);
}
loadAnalysis(pParse, iDb);
}
/*
** Generate code that will do an analysis of a single table in
-** a database.
+** a database. If pOnlyIdx is not NULL then it is a single index
+** in pTab that should be analyzed.
*/
-static void analyzeTable(Parse *pParse, Table *pTab){
+static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
int iDb;
int iStatCur;
@@ -408,8 +412,12 @@ static void analyzeTable(Parse *pParse, Table *pTab){
sqlite3BeginWriteOperation(pParse, 0, iDb);
iStatCur = pParse->nTab;
pParse->nTab += 2;
- openStatTable(pParse, iDb, iStatCur, pTab->zName);
- analyzeOneTable(pParse, pTab, iStatCur, pParse->nMem+1);
+ if( pOnlyIdx ){
+ openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
+ }else{
+ openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
+ }
+ analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur, pParse->nMem+1);
loadAnalysis(pParse, iDb);
}
@@ -431,6 +439,7 @@ void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
int i;
char *z, *zDb;
Table *pTab;
+ Index *pIdx;
Token *pTableName;
/* Read the database schema. If an error occurs, leave an error message
@@ -455,11 +464,12 @@ void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
}else{
z = sqlite3NameFromToken(db, pName1);
if( z ){
- pTab = sqlite3LocateTable(pParse, 0, z, 0);
- sqlite3DbFree(db, z);
- if( pTab ){
- analyzeTable(pParse, pTab);
+ if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
+ analyzeTable(pParse, pIdx->pTable, pIdx);
+ }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
+ analyzeTable(pParse, pTab, 0);
}
+ sqlite3DbFree(db, z);
}
}
}else{
@@ -469,11 +479,12 @@ void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
zDb = db->aDb[iDb].zName;
z = sqlite3NameFromToken(db, pTableName);
if( z ){
- pTab = sqlite3LocateTable(pParse, 0, z, zDb);
- sqlite3DbFree(db, z);
- if( pTab ){
- analyzeTable(pParse, pTab);
+ if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
+ analyzeTable(pParse, pIdx->pTable, pIdx);
+ }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
+ analyzeTable(pParse, pTab, 0);
}
+ sqlite3DbFree(db, z);
}
}
}
diff --git a/src/backup.c b/src/backup.c
index 5d8ea7f3f..82be9635b 100644
--- a/src/backup.c
+++ b/src/backup.c
@@ -488,7 +488,7 @@ int sqlite3_backup_step(sqlite3_backup *p, int nPage){
/* Finish committing the transaction to the destination database. */
if( SQLITE_OK==rc
- && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest))
+ && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
){
rc = SQLITE_DONE;
}
@@ -502,7 +502,7 @@ int sqlite3_backup_step(sqlite3_backup *p, int nPage){
if( bCloseTrans ){
TESTONLY( int rc2 );
TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
- TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc);
+ TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
assert( rc2==SQLITE_OK );
}
diff --git a/src/btree.c b/src/btree.c
index 33d746067..088c555fc 100644
--- a/src/btree.c
+++ b/src/btree.c
@@ -3160,10 +3160,21 @@ static void btreeEndTransaction(Btree *p){
** the rollback journal (which causes the transaction to commit) and
** drop locks.
**
+** Normally, if an error occurs while the pager layer is attempting to
+** finalize the underlying journal file, this function returns an error and
+** the upper layer will attempt a rollback. However, if the second argument
+** is non-zero then this b-tree transaction is part of a multi-file
+** transaction. In this case, the transaction has already been committed
+** (by deleting a master journal file) and the caller will ignore this
+** functions return code. So, even if an error occurs in the pager layer,
+** reset the b-tree objects internal state to indicate that the write
+** transaction has been closed. This is quite safe, as the pager will have
+** transitioned to the error state.
+**
** This will release the write lock on the database file. If there
** are no active cursors, it also releases the read lock.
*/
-int sqlite3BtreeCommitPhaseTwo(Btree *p){
+int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
sqlite3BtreeEnter(p);
@@ -3178,7 +3189,7 @@ int sqlite3BtreeCommitPhaseTwo(Btree *p){
assert( pBt->inTransaction==TRANS_WRITE );
assert( pBt->nTransaction>0 );
rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
- if( rc!=SQLITE_OK ){
+ if( rc!=SQLITE_OK && bCleanup==0 ){
sqlite3BtreeLeave(p);
return rc;
}
@@ -3198,7 +3209,7 @@ int sqlite3BtreeCommit(Btree *p){
sqlite3BtreeEnter(p);
rc = sqlite3BtreeCommitPhaseOne(p, 0);
if( rc==SQLITE_OK ){
- rc = sqlite3BtreeCommitPhaseTwo(p);
+ rc = sqlite3BtreeCommitPhaseTwo(p, 0);
}
sqlite3BtreeLeave(p);
return rc;
diff --git a/src/btree.h b/src/btree.h
index 6886dd944..468723b33 100644
--- a/src/btree.h
+++ b/src/btree.h
@@ -87,7 +87,7 @@ int sqlite3BtreeSetAutoVacuum(Btree *, int);
int sqlite3BtreeGetAutoVacuum(Btree *);
int sqlite3BtreeBeginTrans(Btree*,int);
int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);
-int sqlite3BtreeCommitPhaseTwo(Btree*);
+int sqlite3BtreeCommitPhaseTwo(Btree*, int);
int sqlite3BtreeCommit(Btree*);
int sqlite3BtreeRollback(Btree*);
int sqlite3BtreeBeginStmt(Btree*,int);
diff --git a/src/os_unix.c b/src/os_unix.c
index f4e689fa9..f04b6af27 100644
--- a/src/os_unix.c
+++ b/src/os_unix.c
@@ -371,7 +371,7 @@ static struct unix_syscall {
#else
{ "fallocate", (sqlite3_syscall_ptr)0, 0 },
#endif
-#define osFallocate ((int(*)(int,off_t,off_t)aSyscall[15].pCurrent)
+#define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
}; /* End of the overrideable system calls */
@@ -444,18 +444,16 @@ static sqlite3_syscall_ptr unixGetSystemCall(
** system call.
*/
static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
- unsigned int i;
+ int i = -1;
UNUSED_PARAMETER(p);
- if( zName==0 ){
- i = -1;
- }else{
- for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0])-1; i++){
- if( strcmp(zName, aSyscall[0].zName)==0 ) break;
+ if( zName ){
+ for(i=0; i<ArraySize(aSyscall)-1; i++){
+ if( strcmp(zName, aSyscall[i].zName)==0 ) break;
}
}
- for(i++; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
- if( aSyscall[0].pCurrent!=0 ) return aSyscall[0].zName;
+ for(i++; i<ArraySize(aSyscall); i++){
+ if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
}
return 0;
}
@@ -595,9 +593,22 @@ static int robust_ftruncate(int h, sqlite3_int64 sz){
*/
static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
switch (posixError) {
+#if 0
+ /* At one point this code was not commented out. In theory, this branch
+ ** should never be hit, as this function should only be called after
+ ** a locking-related function (i.e. fcntl()) has returned non-zero with
+ ** the value of errno as the first argument. Since a system call has failed,
+ ** errno should be non-zero.
+ **
+ ** Despite this, if errno really is zero, we still don't want to return
+ ** SQLITE_OK. The system call failed, and *some* SQLite error should be
+ ** propagated back to the caller. Commenting this branch out means errno==0
+ ** will be handled by the "default:" case below.
+ */
case 0:
return SQLITE_OK;
-
+#endif
+
case EAGAIN:
case ETIMEDOUT:
case EBUSY:
@@ -619,8 +630,15 @@ static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
case EPERM:
return SQLITE_PERM;
+ /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
+ ** this module never makes such a call. And the code in SQLite itself
+ ** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons
+ ** this case is also commented out. If the system does set errno to EDEADLK,
+ ** the default SQLITE_IOERR_XXX code will be returned. */
+#if 0
case EDEADLK:
return SQLITE_IOERR_BLOCKED;
+#endif
#if EOPNOTSUPP!=ENOTSUP
case EOPNOTSUPP:
@@ -1039,7 +1057,7 @@ static void closePendingFds(unixFile *pFile){
static void releaseInodeInfo(unixFile *pFile){
unixInodeInfo *pInode = pFile->pInode;
assert( unixMutexHeld() );
- if( pInode ){
+ if( ALWAYS(pInode) ){
pInode->nRef--;
if( pInode->nRef==0 ){
assert( pInode->pShmNode==0 );
@@ -1181,10 +1199,9 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
lock.l_start = RESERVED_BYTE;
lock.l_len = 1;
lock.l_type = F_WRLCK;
- if (-1 == osFcntl(pFile->h, F_GETLK, &lock)) {
- int tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
- pFile->lastErrno = tErrno;
+ if( osFcntl(pFile->h, F_GETLK, &lock) ){
+ rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
+ pFile->lastErrno = errno;
} else if( lock.l_type!=F_UNLCK ){
reserved = 1;
}
@@ -1213,6 +1230,9 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
** This function is a pass-through to fcntl(F_SETLK) if pFile is using
** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
** and is read-only.
+**
+** Zero is returned if the call completes successfully, or -1 if a call
+** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
*/
static int unixFileLock(unixFile *pFile, struct flock *pLock){
int rc;
@@ -1309,7 +1329,6 @@ static int unixLock(sqlite3_file *id, int eFileLock){
unixFile *pFile = (unixFile*)id;
unixInodeInfo *pInode = pFile->pInode;
struct flock lock;
- int s = 0;
int tErrno = 0;
assert( pFile );
@@ -1378,11 +1397,10 @@ static int unixLock(sqlite3_file *id, int eFileLock){
){
lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
lock.l_start = PENDING_BYTE;
- s = unixFileLock(pFile, &lock);
- if( s==(-1) ){
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
goto end_lock;
@@ -1396,33 +1414,31 @@ static int unixLock(sqlite3_file *id, int eFileLock){
if( eFileLock==SHARED_LOCK ){
assert( pInode->nShared==0 );
assert( pInode->eFileLock==0 );
+ assert( rc==SQLITE_OK );
/* Now get the read-lock */
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- if( (s = unixFileLock(pFile, &lock))==(-1) ){
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
+ rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
}
+
/* Drop the temporary PENDING lock */
lock.l_start = PENDING_BYTE;
lock.l_len = 1L;
lock.l_type = F_UNLCK;
- if( unixFileLock(pFile, &lock)!=0 ){
- if( s != -1 ){
- /* This could happen with a network mount */
- tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
- pFile->lastErrno = tErrno;
- }
- goto end_lock;
- }
+ if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
+ /* This could happen with a network mount */
+ tErrno = errno;
+ rc = SQLITE_IOERR_UNLOCK;
}
- if( s==(-1) ){
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+
+ if( rc ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
+ goto end_lock;
}else{
pFile->eFileLock = SHARED_LOCK;
pInode->nLock++;
@@ -1439,22 +1455,20 @@ static int unixLock(sqlite3_file *id, int eFileLock){
*/
assert( 0!=pFile->eFileLock );
lock.l_type = F_WRLCK;
- switch( eFileLock ){
- case RESERVED_LOCK:
- lock.l_start = RESERVED_BYTE;
- break;
- case EXCLUSIVE_LOCK:
- lock.l_start = SHARED_FIRST;
- lock.l_len = SHARED_SIZE;
- break;
- default:
- assert(0);
+
+ assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
+ if( eFileLock==RESERVED_LOCK ){
+ lock.l_start = RESERVED_BYTE;
+ lock.l_len = 1L;
+ }else{
+ lock.l_start = SHARED_FIRST;
+ lock.l_len = SHARED_SIZE;
}
- s = unixFileLock(pFile, &lock);
- if( s==(-1) ){
+
+ if( unixFileLock(pFile, &lock) ){
tErrno = errno;
rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
- if( IS_LOCK_ERROR(rc) ){
+ if( rc!=SQLITE_BUSY ){
pFile->lastErrno = tErrno;
}
}
@@ -1525,7 +1539,6 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
struct flock lock;
int rc = SQLITE_OK;
int h;
- int tErrno; /* Error code from system call errors */
assert( pFile );
OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
@@ -1580,15 +1593,16 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
#endif
#if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
if( handleNFSUnlock ){
+ int tErrno; /* Error code from system call errors */
off_t divSize = SHARED_SIZE - 1;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = divSize;
- if( unixFileLock(pFile,, &lock)==(-1) ){
+ if( unixFileLock(pFile, &lock)==(-1) ){
tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
+ rc = SQLITE_IOERR_UNLOCK;
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
@@ -1612,7 +1626,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
lock.l_len = SHARED_SIZE-divSize;
if( unixFileLock(pFile, &lock)==(-1) ){
tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
+ rc = SQLITE_IOERR_UNLOCK;
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
}
@@ -1625,12 +1639,15 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
lock.l_whence = SEEK_SET;
lock.l_start = SHARED_FIRST;
lock.l_len = SHARED_SIZE;
- if( unixFileLock(pFile, &lock)==(-1) ){
- tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
- if( IS_LOCK_ERROR(rc) ){
- pFile->lastErrno = tErrno;
- }
+ if( unixFileLock(pFile, &lock) ){
+ /* In theory, the call to unixFileLock() cannot fail because another
+ ** process is holding an incompatible lock. If it does, this
+ ** indicates that the other process is not following the locking
+ ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
+ ** SQLITE_BUSY would confuse the upper layer (in practice it causes
+ ** an assert to fail). */
+ rc = SQLITE_IOERR_RDLOCK;
+ pFile->lastErrno = errno;
goto end_unlock;
}
}
@@ -1639,14 +1656,11 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
lock.l_whence = SEEK_SET;
lock.l_start = PENDING_BYTE;
lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
- if( unixFileLock(pFile, &lock)!=(-1) ){
+ if( unixFileLock(pFile, &lock)==0 ){
pInode->eFileLock = SHARED_LOCK;
}else{
- tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
- pFile->lastErrno = tErrno;
- }
+ rc = SQLITE_IOERR_UNLOCK;
+ pFile->lastErrno = errno;
goto end_unlock;
}
}
@@ -1663,14 +1677,11 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
SimulateIOErrorBenign(1);
SimulateIOError( h=(-1) )
SimulateIOErrorBenign(0);
- if( unixFileLock(pFile, &lock)!=(-1) ){
+ if( unixFileLock(pFile, &lock)==0 ){
pInode->eFileLock = NO_LOCK;
}else{
- tErrno = errno;
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(rc) ){
- pFile->lastErrno = tErrno;
- }
+ rc = SQLITE_IOERR_UNLOCK;
+ pFile->lastErrno = errno;
pInode->eFileLock = NO_LOCK;
pFile->eFileLock = NO_LOCK;
}
@@ -1716,29 +1727,27 @@ static int unixUnlock(sqlite3_file *id, int eFileLock){
*/
static int closeUnixFile(sqlite3_file *id){
unixFile *pFile = (unixFile*)id;
- if( pFile ){
- if( pFile->dirfd>=0 ){
- robust_close(pFile, pFile->dirfd, __LINE__);
- pFile->dirfd=-1;
- }
- if( pFile->h>=0 ){
- robust_close(pFile, pFile->h, __LINE__);
- pFile->h = -1;
- }
+ if( pFile->dirfd>=0 ){
+ robust_close(pFile, pFile->dirfd, __LINE__);
+ pFile->dirfd=-1;
+ }
+ if( pFile->h>=0 ){
+ robust_close(pFile, pFile->h, __LINE__);
+ pFile->h = -1;
+ }
#if OS_VXWORKS
- if( pFile->pId ){
- if( pFile->isDelete ){
- unlink(pFile->pId->zCanonicalName);
- }
- vxworksReleaseFileId(pFile->pId);
- pFile->pId = 0;
+ if( pFile->pId ){
+ if( pFile->isDelete ){
+ unlink(pFile->pId->zCanonicalName);
}
-#endif
- OSTRACE(("CLOSE %-3d\n", pFile->h));
- OpenCounter(-1);
- sqlite3_free(pFile->pUnused);
- memset(pFile, 0, sizeof(unixFile));
+ vxworksReleaseFileId(pFile->pId);
+ pFile->pId = 0;
}
+#endif
+ OSTRACE(("CLOSE %-3d\n", pFile->h));
+ OpenCounter(-1);
+ sqlite3_free(pFile->pUnused);
+ memset(pFile, 0, sizeof(unixFile));
return SQLITE_OK;
}
@@ -1747,24 +1756,25 @@ static int closeUnixFile(sqlite3_file *id){
*/
static int unixClose(sqlite3_file *id){
int rc = SQLITE_OK;
- if( id ){
- unixFile *pFile = (unixFile *)id;
- unixUnlock(id, NO_LOCK);
- unixEnterMutex();
- assert( pFile->pInode==0 || pFile->pInode->nLock>0
- || pFile->pInode->bProcessLock==0 );
- if( pFile->pInode && pFile->pInode->nLock ){
- /* If there are outstanding locks, do not actually close the file just
- ** yet because that would clear those locks. Instead, add the file
- ** descriptor to pInode->pUnused list. It will be automatically closed
- ** when the last lock is cleared.
- */
- setPendingFd(pFile);
- }
- releaseInodeInfo(pFile);
- rc = closeUnixFile(id);
- unixLeaveMutex();
+ unixFile *pFile = (unixFile *)id;
+ unixUnlock(id, NO_LOCK);
+ unixEnterMutex();
+
+ /* unixFile.pInode is always valid here. Otherwise, a different close
+ ** routine (e.g. nolockClose()) would be called instead.
+ */
+ assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
+ if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
+ /* If there are outstanding locks, do not actually close the file just
+ ** yet because that would clear those locks. Instead, add the file
+ ** descriptor to pInode->pUnused list. It will be automatically closed
+ ** when the last lock is cleared.
+ */
+ setPendingFd(pFile);
}
+ releaseInodeInfo(pFile);
+ rc = closeUnixFile(id);
+ unixLeaveMutex();
return rc;
}
@@ -1979,7 +1989,7 @@ static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
int rc = 0;
int tErrno = errno;
if( ENOENT != tErrno ){
- rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
+ rc = SQLITE_IOERR_UNLOCK;
}
if( IS_LOCK_ERROR(rc) ){
pFile->lastErrno = tErrno;
@@ -2067,7 +2077,7 @@ static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){
if ( lrc ) {
int tErrno = errno;
/* unlock failed with an error */
- lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
+ lrc = SQLITE_IOERR_UNLOCK;
if( IS_LOCK_ERROR(lrc) ){
pFile->lastErrno = tErrno;
rc = lrc;
@@ -2189,21 +2199,12 @@ static int flockUnlock(sqlite3_file *id, int eFileLock) {
}
/* no, really, unlock. */
- int rc = robust_flock(pFile->h, LOCK_UN);
- if (rc) {
- int r, tErrno = errno;
- r = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
- if( IS_LOCK_ERROR(r) ){
- pFile->lastErrno = tErrno;
- }
+ if( robust_flock(pFile->h, LOCK_UN) ){
#ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
- if( (r & SQLITE_IOERR) == SQLITE_IOERR ){
- r = SQLITE_BUSY;
- }
+ return SQLITE_OK;
#endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
-
- return r;
- } else {
+ return SQLITE_IOERR_UNLOCK;
+ }else{
pFile->eFileLock = NO_LOCK;
return SQLITE_OK;
}
@@ -3009,6 +3010,7 @@ static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
#else
newOffset = lseek(id->h, offset, SEEK_SET);
+ SimulateIOError( newOffset-- );
if( newOffset!=offset ){
if( newOffset == -1 ){
((unixFile*)id)->lastErrno = errno;
@@ -3377,12 +3379,16 @@ static int fcntlSizeHint(unixFile *pFile, i64 nByte){
nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
if( nSize>(i64)buf.st_size ){
+
#if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
- int rc;
+ /* The code below is handling the return value of osFallocate()
+ ** correctly. posix_fallocate() is defined to "returns zero on success,
+ ** or an error number on failure". See the manpage for details. */
+ int err;
do{
- rc = osFallocate(pFile->.h, buf.st_size, nSize-buf.st_size;
- }while( rc<0 && errno=EINTR );
- if( rc ) return SQLITE_IOERR_WRITE;
+ err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
+ }while( err==EINTR );
+ if( err ) return SQLITE_IOERR_WRITE;
#else
/* If the OS does not have posix_fallocate(), fake it. First use
** ftruncate() to set the file size, then write a single byte to
@@ -5735,7 +5741,9 @@ static int proxyCreateUnixFile(
}
memset(pNew, 0, sizeof(unixFile));
pNew->openFlags = openFlags;
+ memset(&dummyVfs, 0, sizeof(dummyVfs));
dummyVfs.pAppData = (void*)&autolockIoFinder;
+ dummyVfs.zName = "dummy";
pUnused->fd = fd;
pUnused->flags = openFlags;
pNew->pUnused = pUnused;
diff --git a/src/sqlite.h.in b/src/sqlite.h.in
index d3be1b32a..c4dc4a6ef 100644
--- a/src/sqlite.h.in
+++ b/src/sqlite.h.in
@@ -2975,7 +2975,9 @@ int sqlite3_column_count(sqlite3_stmt *pStmt);
** column number. ^The leftmost column is number 0.
**
** ^The returned string pointer is valid until either the [prepared statement]
-** is destroyed by [sqlite3_finalize()] or until the next call to
+** is destroyed by [sqlite3_finalize()] or until the statement is automatically
+** reprepared by the first call to [sqlite3_step()] for a particular run
+** or until the next call to
** sqlite3_column_name() or sqlite3_column_name16() on the same column.
**
** ^If sqlite3_malloc() fails during the processing of either routine
@@ -3001,7 +3003,9 @@ const void *sqlite3_column_name16(sqlite3_stmt*, int N);
** the database name, the _table_ routines return the table name, and
** the origin_ routines return the column name.
** ^The returned string is valid until the [prepared statement] is destroyed
-** using [sqlite3_finalize()] or until the same information is requested
+** using [sqlite3_finalize()] or until the statement is automatically
+** reprepared by the first call to [sqlite3_step()] for a particular run
+** or until the same information is requested
** again in a different encoding.
**
** ^The names returned are the original un-aliased names of the
diff --git a/src/tclsqlite.c b/src/tclsqlite.c
index e77a1ee91..79ee1946b 100644
--- a/src/tclsqlite.c
+++ b/src/tclsqlite.c
@@ -3581,6 +3581,7 @@ static void init_all(Tcl_Interp *interp){
extern int Sqlitequota_Init(Tcl_Interp*);
extern int Sqlitemultiplex_Init(Tcl_Interp*);
extern int SqliteSuperlock_Init(Tcl_Interp*);
+ extern int SqlitetestSyscall_Init(Tcl_Interp*);
extern int Sqlitetestfuzzer_Init(Tcl_Interp*);
#ifdef SQLITE_ENABLE_ZIPVFS
@@ -3619,6 +3620,7 @@ static void init_all(Tcl_Interp *interp){
Sqlitequota_Init(interp);
Sqlitemultiplex_Init(interp);
SqliteSuperlock_Init(interp);
+ SqlitetestSyscall_Init(interp);
Sqlitetestfuzzer_Init(interp);
Tcl_CreateObjCommand(interp,"load_testfixture_extensions",init_all_cmd,0,0);
diff --git a/src/test1.c b/src/test1.c
index 852ecdecc..8a0d09a71 100644
--- a/src/test1.c
+++ b/src/test1.c
@@ -4889,6 +4889,44 @@ static int file_control_chunksize_test(
}
/*
+** tclcmd: file_control_sizehint_test DB DBNAME SIZE
+**
+** This TCL command runs the sqlite3_file_control interface and
+** verifies correct operation of the SQLITE_GET_LOCKPROXYFILE and
+** SQLITE_SET_LOCKPROXYFILE verbs.
+*/
+static int file_control_sizehint_test(
+ ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
+ Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
+ int objc, /* Number of arguments */
+ Tcl_Obj *CONST objv[] /* Command arguments */
+){
+ sqlite3_int64 nSize; /* Hinted size */
+ char *zDb; /* Db name ("main", "temp" etc.) */
+ sqlite3 *db; /* Database handle */
+ int rc; /* file_control() return code */
+
+ if( objc!=4 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "DB DBNAME SIZE");
+ return TCL_ERROR;
+ }
+ if( getDbPointer(interp, Tcl_GetString(objv[1]), &db)
+ || Tcl_GetWideIntFromObj(interp, objv[3], &nSize)
+ ){
+ return TCL_ERROR;
+ }
+ zDb = Tcl_GetString(objv[2]);
+ if( zDb[0]=='\0' ) zDb = NULL;
+
+ rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_SIZE_HINT, (void *)&nSize);
+ if( rc ){
+ Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
+ return TCL_ERROR;
+ }
+ return TCL_OK;
+}
+
+/*
** tclcmd: file_control_lockproxy_test DB PWD
**
** This TCL command runs the sqlite3_file_control interface and
@@ -5608,6 +5646,7 @@ int Sqlitetest1_Init(Tcl_Interp *interp){
{ "file_control_lasterrno_test", file_control_lasterrno_test, 0 },
{ "file_control_lockproxy_test", file_control_lockproxy_test, 0 },
{ "file_control_chunksize_test", file_control_chunksize_test, 0 },
+ { "file_control_sizehint_test", file_control_sizehint_test, 0 },
{ "sqlite3_vfs_list", vfs_list, 0 },
{ "sqlite3_create_function_v2", test_create_function_v2, 0 },
diff --git a/src/test_hexio.c b/src/test_hexio.c
index 02bd60c8a..e3258e869 100644
--- a/src/test_hexio.c
+++ b/src/test_hexio.c
@@ -312,8 +312,13 @@ static int utf8_to_utf8(
sqlite3TestBinToHex(z,nOut);
Tcl_AppendResult(interp, (char*)z, 0);
sqlite3_free(z);
-#endif
return TCL_OK;
+#else
+ Tcl_AppendResult(interp,
+ "[utf8_to_utf8] unavailable - SQLITE_DEBUG not defined", 0
+ );
+ return TCL_ERROR;
+#endif
}
static int getFts3Varint(const char *p, sqlite_int64 *v){
diff --git a/src/test_multiplex.c b/src/test_multiplex.c
index 72a71621b..d8a7db86e 100644
--- a/src/test_multiplex.c
+++ b/src/test_multiplex.c
@@ -22,7 +22,22 @@
#include "sqlite3.h"
#include <string.h>
#include <assert.h>
-#include "sqliteInt.h"
+#include "test_multiplex.h"
+
+#ifndef SQLITE_CORE
+ #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
+#endif
+#include "sqlite3ext.h"
+
+/*
+** These should be defined to be the same as the values in
+** sqliteInt.h. They are defined seperately here so that
+** the multiplex VFS shim can be built as a loadable
+** module.
+*/
+#define UNUSED_PARAMETER(x) (void)(x)
+#define MAX_PAGE_SIZE 0x10000
+#define DEFAULT_SECTOR_SIZE 0x1000
/*
** For a build without mutexes, no-op the mutex calls.
@@ -40,14 +55,18 @@
/************************ Shim Definitions ******************************/
+#define SQLITE_MULTIPLEX_VFS_NAME "multiplex"
+
/* This is the limit on the chunk size. It may be changed by calling
-** the sqlite3_multiplex_set() interface.
+** the xFileControl() interface. It will be rounded up to a
+** multiple of MAX_PAGE_SIZE. We default it here to 1GB.
*/
-#define SQLITE_MULTIPLEX_CHUNK_SIZE 0x40000000
+#define SQLITE_MULTIPLEX_CHUNK_SIZE (MAX_PAGE_SIZE*16384)
+
/* Default limit on number of chunks. Care should be taken
** so that values for chunks numbers fit in the SQLITE_MULTIPLEX_EXT_FMT
** format specifier. It may be changed by calling
-** the sqlite3_multiplex_set() interface.
+** the xFileControl() interface.
*/
#define SQLITE_MULTIPLEX_MAX_CHUNKS 32
@@ -82,6 +101,9 @@ struct multiplexGroup {
char *zName; /* Base filename of this group */
int nName; /* Length of base filename */
int flags; /* Flags used for original opening */
+ int nChunkSize; /* Chunk size used for this group */
+ int nMaxChunks; /* Max number of chunks for this group */
+ int bEnabled; /* TRUE to use Multiplex VFS for this file */
multiplexGroup *pNext, *pPrev; /* Doubly linked list of all group objects */
};
@@ -140,11 +162,6 @@ static struct {
*/
multiplexGroup *pGroups;
- /* Chunk params.
- */
- int nChunkSize;
- int nMaxChunks;
-
/* Storage for temp file names. Allocated during
** initialization to the max pathname of the underlying VFS.
*/
@@ -160,13 +177,28 @@ static struct {
static void multiplexEnter(void){ sqlite3_mutex_enter(gMultiplex.pMutex); }
static void multiplexLeave(void){ sqlite3_mutex_leave(gMultiplex.pMutex); }
+/*
+** Compute a string length that is limited to what can be stored in
+** lower 30 bits of a 32-bit signed integer.
+**
+** The value returned will never be negative. Nor will it ever be greater
+** than the actual length of the string. For very long strings (greater
+** than 1GiB) the value returned might be less than the true string length.
+*/
+int multiplexStrlen30(const char *z){
+ const char *z2 = z;
+ if( z==0 ) return 0;
+ while( *z2 ){ z2++; }
+ return 0x3fffffff & (int)(z2 - z);
+}
+
/* Translate an sqlite3_file* that is really a multiplexGroup* into
** the sqlite3_file* for the underlying original VFS.
*/
static sqlite3_file *multiplexSubOpen(multiplexConn *pConn, int iChunk, int *rc, int *pOutFlags){
multiplexGroup *pGroup = pConn->pGroup;
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
- if( iChunk<gMultiplex.nMaxChunks ){
+ if( iChunk<pGroup->nMaxChunks ){
sqlite3_file *pSubOpen = pGroup->pReal[iChunk]; /* Real file descriptor */
if( !pGroup->bOpen[iChunk] ){
memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
@@ -191,6 +223,62 @@ static sqlite3_file *multiplexSubOpen(multiplexConn *pConn, int iChunk, int *rc,
return NULL;
}
+/*
+** This is the implementation of the multiplex_control() SQL function.
+*/
+static void multiplexControlFunc(
+ sqlite3_context *context,
+ int argc,
+ sqlite3_value **argv
+){
+ int rc = SQLITE_OK;
+ sqlite3 *db = sqlite3_context_db_handle(context);
+ int op;
+ int iVal;
+
+ if( !db || argc!=2 ){
+ rc = SQLITE_ERROR;
+ }else{
+ /* extract params */
+ op = sqlite3_value_int(argv[0]);
+ iVal = sqlite3_value_int(argv[1]);
+ /* map function op to file_control op */
+ switch( op ){
+ case 1:
+ op = MULTIPLEX_CTRL_ENABLE;
+ break;
+ case 2:
+ op = MULTIPLEX_CTRL_SET_CHUNK_SIZE;
+ break;
+ case 3:
+ op = MULTIPLEX_CTRL_SET_MAX_CHUNKS;
+ break;
+ default:
+ rc = SQLITE_NOTFOUND;
+ break;
+ }
+ }
+ if( rc==SQLITE_OK ){
+ rc = sqlite3_file_control(db, 0, op, &iVal);
+ }
+ sqlite3_result_error_code(context, rc);
+}
+
+/*
+** This is the entry point to register the auto-extension for the
+** multiplex_control() function.
+*/
+static int multiplexFuncInit(
+ sqlite3 *db,
+ char **pzErrMsg,
+ const sqlite3_api_routines *pApi
+){
+ int rc;
+ rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY,
+ 0, multiplexControlFunc, 0, 0);
+ return rc;
+}
+
/************************* VFS Method Wrappers *****************************/
/*
@@ -212,7 +300,7 @@ static int multiplexOpen(
multiplexGroup *pGroup; /* Corresponding multiplexGroup object */
sqlite3_file *pSubOpen; /* Real file descriptor */
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
- int nName = sqlite3Strlen30(zName);
+ int nName = multiplexStrlen30(zName);
int i;
int sz;
@@ -224,11 +312,11 @@ static int multiplexOpen(
multiplexEnter();
pMultiplexOpen = (multiplexConn*)pConn;
/* allocate space for group */
- sz = sizeof(multiplexGroup) /* multiplexGroup */
- + (sizeof(sqlite3_file *)*gMultiplex.nMaxChunks) /* pReal[] */
- + (pOrigVfs->szOsFile*gMultiplex.nMaxChunks) /* *pReal */
- + gMultiplex.nMaxChunks /* bOpen[] */
- + nName + 1; /* zName */
+ sz = sizeof(multiplexGroup) /* multiplexGroup */
+ + (sizeof(sqlite3_file *)*SQLITE_MULTIPLEX_MAX_CHUNKS) /* pReal[] */
+ + (pOrigVfs->szOsFile*SQLITE_MULTIPLEX_MAX_CHUNKS) /* *pReal */
+ + SQLITE_MULTIPLEX_MAX_CHUNKS /* bOpen[] */
+ + nName + 1; /* zName */
#ifndef SQLITE_MULTIPLEX_EXT_OVWR
sz += SQLITE_MULTIPLEX_EXT_SZ;
assert(nName+SQLITE_MULTIPLEX_EXT_SZ < pOrigVfs->mxPathname);
@@ -244,14 +332,18 @@ static int multiplexOpen(
char *p = (char *)&pGroup[1];
pMultiplexOpen->pGroup = pGroup;
memset(pGroup, 0, sz);
+ pGroup->bEnabled = -1;
+ pGroup->nChunkSize = SQLITE_MULTIPLEX_CHUNK_SIZE;
+ pGroup->nMaxChunks = SQLITE_MULTIPLEX_MAX_CHUNKS;
pGroup->pReal = (sqlite3_file **)p;
- p += (sizeof(sqlite3_file *)*gMultiplex.nMaxChunks);
- for(i=0; i<gMultiplex.nMaxChunks; i++){
+ p += (sizeof(sqlite3_file *)*pGroup->nMaxChunks);
+ for(i=0; i<pGroup->nMaxChunks; i++){
pGroup->pReal[i] = (sqlite3_file *)p;
p += pOrigVfs->szOsFile;
}
+ /* bOpen[] vals should all be zero from memset above */
pGroup->bOpen = p;
- p += gMultiplex.nMaxChunks;
+ p += pGroup->nMaxChunks;
pGroup->zName = p;
/* save off base filename, name length, and original open flags */
memcpy(pGroup->zName, zName, nName+1);
@@ -259,6 +351,14 @@ static int multiplexOpen(
pGroup->flags = flags;
pSubOpen = multiplexSubOpen(pMultiplexOpen, 0, &rc, pOutFlags);
if( pSubOpen ){
+ /* if this file is already larger than chunk size, disable
+ ** the multiplex feature.
+ */
+ sqlite3_int64 sz;
+ int rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
+ if( (rc2==SQLITE_OK) && (sz>pGroup->nChunkSize) ){
+ pGroup->bEnabled = 0;
+ }
if( pSubOpen->pMethods->iVersion==1 ){
pMultiplexOpen->base.pMethods = &gMultiplex.sIoMethodsV1;
}else{
@@ -288,24 +388,29 @@ static int multiplexDelete(
){
sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
int rc = SQLITE_OK;
- int nName = sqlite3Strlen30(zName);
+ int nName = multiplexStrlen30(zName);
int i;
UNUSED_PARAMETER(pVfs);
multiplexEnter();
memcpy(gMultiplex.zName, zName, nName+1);
- for(i=0; i<gMultiplex.nMaxChunks; i++){
+ for(i=0; i<SQLITE_MULTIPLEX_MAX_CHUNKS; i++){
int rc2;
int exists = 0;
if( i ){
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+nName-SQLITE_MULTIPLEX_EXT_SZ,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#else
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+nName, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+nName,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#endif
}
- rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName, SQLITE_ACCESS_EXISTS, &exists);
+ rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName,
+ SQLITE_ACCESS_EXISTS, &exists);
if( rc2==SQLITE_OK && exists){
/* if it exists, delete it */
rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, syncDir);
@@ -367,7 +472,7 @@ static int multiplexClose(sqlite3_file *pConn){
int i;
multiplexEnter();
/* close any open handles */
- for(i=0; i<gMultiplex.nMaxChunks; i++){
+ for(i=0; i<pGroup->nMaxChunks; i++){
if( pGroup->bOpen[i] ){
sqlite3_file *pSubOpen = pGroup->pReal[i];
int rc2 = pSubOpen->pMethods->xClose(pSubOpen);
@@ -398,23 +503,29 @@ static int multiplexRead(
sqlite3_int64 iOfst
){
multiplexConn *p = (multiplexConn*)pConn;
+ multiplexGroup *pGroup = p->pGroup;
int rc = SQLITE_OK;
multiplexEnter();
- while( iAmt > 0 ){
- int i = (int)(iOfst/gMultiplex.nChunkSize);
- sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
- if( pSubOpen ){
- int extra = ((int)(iOfst % gMultiplex.nChunkSize) + iAmt) - gMultiplex.nChunkSize;
- if( extra<0 ) extra = 0;
- iAmt -= extra;
- rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst%gMultiplex.nChunkSize);
- if( rc!=SQLITE_OK ) break;
- pBuf = (char *)pBuf + iAmt;
- iOfst += iAmt;
- iAmt = extra;
- }else{
- rc = SQLITE_IOERR_READ;
- break;
+ if( !pGroup->bEnabled ){
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
+ rc = ( !pSubOpen ) ? SQLITE_IOERR_READ : pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
+ }else{
+ while( iAmt > 0 ){
+ int i = (int)(iOfst / pGroup->nChunkSize);
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
+ if( pSubOpen ){
+ int extra = ((int)(iOfst % pGroup->nChunkSize) + iAmt) - pGroup->nChunkSize;
+ if( extra<0 ) extra = 0;
+ iAmt -= extra;
+ rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst % pGroup->nChunkSize);
+ if( rc!=SQLITE_OK ) break;
+ pBuf = (char *)pBuf + iAmt;
+ iOfst += iAmt;
+ iAmt = extra;
+ }else{
+ rc = SQLITE_IOERR_READ;
+ break;
+ }
}
}
multiplexLeave();
@@ -432,23 +543,29 @@ static int multiplexWrite(
sqlite3_int64 iOfst
){
multiplexConn *p = (multiplexConn*)pConn;
+ multiplexGroup *pGroup = p->pGroup;
int rc = SQLITE_OK;
multiplexEnter();
- while( iAmt > 0 ){
- int i = (int)(iOfst/gMultiplex.nChunkSize);
- sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
- if( pSubOpen ){
- int extra = ((int)(iOfst % gMultiplex.nChunkSize) + iAmt) - gMultiplex.nChunkSize;
- if( extra<0 ) extra = 0;
- iAmt -= extra;
- rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst%gMultiplex.nChunkSize);
- if( rc!=SQLITE_OK ) break;
- pBuf = (char *)pBuf + iAmt;
- iOfst += iAmt;
- iAmt = extra;
- }else{
- rc = SQLITE_IOERR_WRITE;
- break;
+ if( !pGroup->bEnabled ){
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
+ rc = ( !pSubOpen ) ? SQLITE_IOERR_WRITE : pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
+ }else{
+ while( iAmt > 0 ){
+ int i = (int)(iOfst / pGroup->nChunkSize);
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
+ if( pSubOpen ){
+ int extra = ((int)(iOfst % pGroup->nChunkSize) + iAmt) - pGroup->nChunkSize;
+ if( extra<0 ) extra = 0;
+ iAmt -= extra;
+ rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst % pGroup->nChunkSize);
+ if( rc!=SQLITE_OK ) break;
+ pBuf = (char *)pBuf + iAmt;
+ iOfst += iAmt;
+ iAmt = extra;
+ }else{
+ rc = SQLITE_IOERR_WRITE;
+ break;
+ }
}
}
multiplexLeave();
@@ -463,35 +580,44 @@ static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
multiplexConn *p = (multiplexConn*)pConn;
multiplexGroup *pGroup = p->pGroup;
int rc = SQLITE_OK;
- int rc2;
- int i;
- sqlite3_file *pSubOpen;
- sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
multiplexEnter();
- memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
- /* delete the chunks above the truncate limit */
- for(i=(int)(size/gMultiplex.nChunkSize)+1; i<gMultiplex.nMaxChunks; i++){
- /* close any open chunks before deleting them */
- if( pGroup->bOpen[i] ){
- pSubOpen = pGroup->pReal[i];
- rc2 = pSubOpen->pMethods->xClose(pSubOpen);
- if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
- pGroup->bOpen[i] = 0;
- }
+ if( !pGroup->bEnabled ){
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
+ rc = ( !pSubOpen ) ? SQLITE_IOERR_TRUNCATE : pSubOpen->pMethods->xTruncate(pSubOpen, size);
+ }else{
+ int rc2;
+ int i;
+ sqlite3_file *pSubOpen;
+ sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
+ memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
+ /* delete the chunks above the truncate limit */
+ for(i=(int)(size / pGroup->nChunkSize)+1; i<pGroup->nMaxChunks; i++){
+ /* close any open chunks before deleting them */
+ if( pGroup->bOpen[i] ){
+ pSubOpen = pGroup->pReal[i];
+ rc2 = pSubOpen->pMethods->xClose(pSubOpen);
+ if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
+ pGroup->bOpen[i] = 0;
+ }
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#else
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+pGroup->nName,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#endif
- rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, 0);
- if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
- }
- pSubOpen = multiplexSubOpen(p, (int)(size/gMultiplex.nChunkSize), &rc2, NULL);
- if( pSubOpen ){
- rc2 = pSubOpen->pMethods->xTruncate(pSubOpen, size%gMultiplex.nChunkSize);
- if( rc2!=SQLITE_OK ) rc = rc2;
- }else{
- rc = SQLITE_IOERR_TRUNCATE;
+ rc2 = pOrigVfs->xDelete(pOrigVfs, gMultiplex.zName, 0);
+ if( rc2!=SQLITE_OK ) rc = SQLITE_IOERR_TRUNCATE;
+ }
+ pSubOpen = multiplexSubOpen(p, (int)(size / pGroup->nChunkSize), &rc2, NULL);
+ if( pSubOpen ){
+ rc2 = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->nChunkSize);
+ if( rc2!=SQLITE_OK ) rc = rc2;
+ }else{
+ rc = SQLITE_IOERR_TRUNCATE;
+ }
}
multiplexLeave();
return rc;
@@ -505,7 +631,7 @@ static int multiplexSync(sqlite3_file *pConn, int flags){
int rc = SQLITE_OK;
int i;
multiplexEnter();
- for(i=0; i<gMultiplex.nMaxChunks; i++){
+ for(i=0; i<pGroup->nMaxChunks; i++){
/* if we don't have it open, we don't need to sync it */
if( pGroup->bOpen[i] ){
sqlite3_file *pSubOpen = pGroup->pReal[i];
@@ -527,46 +653,56 @@ static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
int rc2;
int i;
multiplexEnter();
- *pSize = 0;
- for(i=0; i<gMultiplex.nMaxChunks; i++){
- sqlite3_file *pSubOpen = NULL;
- /* if not opened already, check to see if the chunk exists */
- if( pGroup->bOpen[i] ){
- pSubOpen = pGroup->pReal[i];
- }else{
- sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
- int exists = 0;
- memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
- if( i ){
+ if( !pGroup->bEnabled ){
+ sqlite3_file *pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
+ rc = ( !pSubOpen ) ? SQLITE_IOERR_FSTAT : pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
+ }else{
+ *pSize = 0;
+ for(i=0; i<pGroup->nMaxChunks; i++){
+ sqlite3_file *pSubOpen = NULL;
+ /* if not opened already, check to see if the chunk exists */
+ if( pGroup->bOpen[i] ){
+ pSubOpen = pGroup->pReal[i];
+ }else{
+ sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs; /* Real VFS */
+ int exists = 0;
+ memcpy(gMultiplex.zName, pGroup->zName, pGroup->nName+1);
+ if( i ){
#ifdef SQLITE_MULTIPLEX_EXT_OVWR
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+pGroup->nName-SQLITE_MULTIPLEX_EXT_SZ,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#else
- sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1, gMultiplex.zName+pGroup->nName, SQLITE_MULTIPLEX_EXT_FMT, i);
+ sqlite3_snprintf(SQLITE_MULTIPLEX_EXT_SZ+1,
+ gMultiplex.zName+pGroup->nName,
+ SQLITE_MULTIPLEX_EXT_FMT, i);
#endif
+ }
+ rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName,
+ SQLITE_ACCESS_EXISTS, &exists);
+ if( rc2==SQLITE_OK && exists){
+ /* if it exists, open it */
+ pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
+ }else{
+ /* stop at first "gap" */
+ break;
+ }
}
- rc2 = pOrigVfs->xAccess(pOrigVfs, gMultiplex.zName, SQLITE_ACCESS_EXISTS, &exists);
- if( rc2==SQLITE_OK && exists){
- /* if it exists, open it */
- pSubOpen = multiplexSubOpen(p, i, &rc, NULL);
+ if( pSubOpen ){
+ sqlite3_int64 sz;
+ rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
+ if( rc2!=SQLITE_OK ){
+ rc = rc2;
+ }else{
+ if( sz>pGroup->nChunkSize ){
+ rc = SQLITE_IOERR_FSTAT;
+ }
+ *pSize += sz;
+ }
}else{
- /* stop at first "gap" */
break;
}
}
- if( pSubOpen ){
- sqlite3_int64 sz;
- rc2 = pSubOpen->pMethods->xFileSize(pSubOpen, &sz);
- if( rc2!=SQLITE_OK ){
- rc = rc2;
- }else{
- if( sz>gMultiplex.nChunkSize ){
- rc = SQLITE_IOERR_FSTAT;
- }
- *pSize += sz;
- }
- }else{
- break;
- }
}
multiplexLeave();
return rc;
@@ -608,18 +744,62 @@ static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){
return SQLITE_IOERR_CHECKRESERVEDLOCK;
}
-/* Pass xFileControl requests through to the original VFS unchanged.
+/* Pass xFileControl requests through to the original VFS unchanged,
+** except for any MULTIPLEX_CTRL_* requests here.
*/
static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
multiplexConn *p = (multiplexConn*)pConn;
- int rc;
+ multiplexGroup *pGroup = p->pGroup;
+ int rc = SQLITE_ERROR;
sqlite3_file *pSubOpen;
- if ( op==SQLITE_FCNTL_SIZE_HINT || op==SQLITE_FCNTL_CHUNK_SIZE ) return SQLITE_OK;
- pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
- if( pSubOpen ){
- return pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
+
+ if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
+ switch( op ){
+ case MULTIPLEX_CTRL_ENABLE:
+ if( pArg ) {
+ int bEnabled = *(int *)pArg;
+ pGroup->bEnabled = bEnabled;
+ rc = SQLITE_OK;
+ }
+ break;
+ case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
+ if( pArg ) {
+ int nChunkSize = *(int *)pArg;
+ if( nChunkSize<1 ){
+ rc = SQLITE_MISUSE;
+ }else{
+ /* Round up to nearest multiple of MAX_PAGE_SIZE. */
+ nChunkSize = (nChunkSize + (MAX_PAGE_SIZE-1));
+ nChunkSize &= ~(MAX_PAGE_SIZE-1);
+ pGroup->nChunkSize = nChunkSize;
+ rc = SQLITE_OK;
+ }
+ }
+ break;
+ case MULTIPLEX_CTRL_SET_MAX_CHUNKS:
+ if( pArg ) {
+ int nMaxChunks = *(int *)pArg;
+ if(( nMaxChunks<1 ) || ( nMaxChunks>SQLITE_MULTIPLEX_MAX_CHUNKS )){
+ rc = SQLITE_MISUSE;
+ }else{
+ pGroup->nMaxChunks = nMaxChunks;
+ rc = SQLITE_OK;
+ }
+ }
+ break;
+ case SQLITE_FCNTL_SIZE_HINT:
+ case SQLITE_FCNTL_CHUNK_SIZE:
+ /* no-op these */
+ rc = SQLITE_OK;
+ break;
+ default:
+ pSubOpen = multiplexSubOpen(p, 0, &rc, NULL);
+ if( pSubOpen ){
+ rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
+ }
+ break;
}
- return SQLITE_ERROR;
+ return rc;
}
/* Pass xSectorSize requests through to the original VFS unchanged.
@@ -631,7 +811,7 @@ static int multiplexSectorSize(sqlite3_file *pConn){
if( pSubOpen ){
return pSubOpen->pMethods->xSectorSize(pSubOpen);
}
- return SQLITE_DEFAULT_SECTOR_SIZE;
+ return DEFAULT_SECTOR_SIZE;
}
/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
@@ -706,9 +886,10 @@ static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){
/************************** Public Interfaces *****************************/
/*
-** Initialize the multiplex VFS shim. Use the VFS named zOrigVfsName
-** as the VFS that does the actual work. Use the default if
-** zOrigVfsName==NULL.
+** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
+**
+** Use the VFS named zOrigVfsName as the VFS that does the actual work.
+** Use the default if zOrigVfsName==NULL.
**
** The multiplex VFS shim is named "multiplex". It will become the default
** VFS if makeDefault is non-zero.
@@ -731,14 +912,12 @@ int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
sqlite3_mutex_free(gMultiplex.pMutex);
return SQLITE_NOMEM;
}
- gMultiplex.nChunkSize = SQLITE_MULTIPLEX_CHUNK_SIZE;
- gMultiplex.nMaxChunks = SQLITE_MULTIPLEX_MAX_CHUNKS;
gMultiplex.pGroups = NULL;
gMultiplex.isInitialized = 1;
gMultiplex.pOrigVfs = pOrigVfs;
gMultiplex.sThisVfs = *pOrigVfs;
gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
- gMultiplex.sThisVfs.zName = "multiplex";
+ gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
gMultiplex.sThisVfs.xOpen = multiplexOpen;
gMultiplex.sThisVfs.xDelete = multiplexDelete;
gMultiplex.sThisVfs.xAccess = multiplexAccess;
@@ -773,11 +952,14 @@ int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);
+
+ sqlite3_auto_extension((void*)multiplexFuncInit);
+
return SQLITE_OK;
}
/*
-** Shutdown the multiplex system.
+** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
**
** All SQLite database connections must be closed before calling this
** routine.
@@ -796,31 +978,9 @@ int sqlite3_multiplex_shutdown(void){
return SQLITE_OK;
}
-/*
-** Adjust chunking params. VFS should be initialized first.
-** No files should be open. Re-intializing will reset these
-** to the default.
-*/
-int sqlite3_multiplex_set(
- int nChunkSize, /* Max chunk size */
- int nMaxChunks /* Max number of chunks */
-){
- if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
- if( gMultiplex.pGroups ) return SQLITE_MISUSE;
- if( nChunkSize<32 ) return SQLITE_MISUSE;
- if( nMaxChunks<1 ) return SQLITE_MISUSE;
- if( nMaxChunks>99 ) return SQLITE_MISUSE;
- multiplexEnter();
- gMultiplex.nChunkSize = nChunkSize;
- gMultiplex.nMaxChunks = nMaxChunks;
- multiplexLeave();
- return SQLITE_OK;
-}
-
/***************************** Test Code ***********************************/
#ifdef SQLITE_TEST
#include <tcl.h>
-
extern const char *sqlite3TestErrorName(int);
@@ -881,36 +1041,6 @@ static int test_multiplex_shutdown(
}
/*
-** tclcmd: sqlite3_multiplex_set CHUNK_SIZE MAX_CHUNKS
-*/
-static int test_multiplex_set(
- void * clientData,
- Tcl_Interp *interp,
- int objc,
- Tcl_Obj *CONST objv[]
-){
- int nChunkSize; /* Max chunk size */
- int nMaxChunks; /* Max number of chunks */
- int rc; /* Value returned by sqlite3_multiplex_set() */
-
- UNUSED_PARAMETER(clientData);
-
- /* Process arguments */
- if( objc!=3 ){
- Tcl_WrongNumArgs(interp, 1, objv, "CHUNK_SIZE MAX_CHUNKS");
- return TCL_ERROR;
- }
- if( Tcl_GetIntFromObj(interp, objv[1], &nChunkSize) ) return TCL_ERROR;
- if( Tcl_GetIntFromObj(interp, objv[2], &nMaxChunks) ) return TCL_ERROR;
-
- /* Invoke sqlite3_multiplex_set() */
- rc = sqlite3_multiplex_set(nChunkSize, nMaxChunks);
-
- Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
- return TCL_OK;
-}
-
-/*
** tclcmd: sqlite3_multiplex_dump
*/
static int test_multiplex_dump(
@@ -943,16 +1073,16 @@ static int test_multiplex_dump(
Tcl_NewIntObj(pGroup->flags));
/* count number of chunks with open handles */
- for(i=0; i<gMultiplex.nMaxChunks; i++){
+ for(i=0; i<pGroup->nMaxChunks; i++){
if( pGroup->bOpen[i] ) nChunks++;
}
Tcl_ListObjAppendElement(interp, pGroupTerm,
Tcl_NewIntObj(nChunks));
Tcl_ListObjAppendElement(interp, pGroupTerm,
- Tcl_NewIntObj(gMultiplex.nChunkSize));
+ Tcl_NewIntObj(pGroup->nChunkSize));
Tcl_ListObjAppendElement(interp, pGroupTerm,
- Tcl_NewIntObj(gMultiplex.nMaxChunks));
+ Tcl_NewIntObj(pGroup->nMaxChunks));
Tcl_ListObjAppendElement(interp, pResult, pGroupTerm);
}
@@ -962,6 +1092,68 @@ static int test_multiplex_dump(
}
/*
+** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
+*/
+static int test_multiplex_control(
+ ClientData cd,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ int rc; /* Return code from file_control() */
+ int idx; /* Index in aSub[] */
+ Tcl_CmdInfo cmdInfo; /* Command info structure for HANDLE */
+ sqlite3 *db; /* Underlying db handle for HANDLE */
+ int iValue = 0;
+ void *pArg = 0;
+
+ struct SubCommand {
+ const char *zName;
+ int op;
+ int argtype;
+ } aSub[] = {
+ { "enable", MULTIPLEX_CTRL_ENABLE, 1 },
+ { "chunk_size", MULTIPLEX_CTRL_SET_CHUNK_SIZE, 1 },
+ { "max_chunks", MULTIPLEX_CTRL_SET_MAX_CHUNKS, 1 },
+ { 0, 0, 0 }
+ };
+
+ if( objc!=5 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE");
+ return TCL_ERROR;
+ }
+
+ if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
+ Tcl_AppendResult(interp, "expected database handle, got \"", 0);
+ Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0);
+ return TCL_ERROR;
+ }else{
+ db = *(sqlite3 **)cmdInfo.objClientData;
+ }
+
+ rc = Tcl_GetIndexFromObjStruct(
+ interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx
+ );
+ if( rc!=TCL_OK ) return rc;
+
+ switch( aSub[idx].argtype ){
+ case 1:
+ if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){
+ return TCL_ERROR;
+ }
+ pArg = (void *)&iValue;
+ break;
+ default:
+ Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND");
+ return TCL_ERROR;
+ }
+
+ rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg);
+ Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), TCL_STATIC);
+ return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR;
+}
+
+/*
** This routine registers the custom TCL commands defined in this
** module. This should be the only procedure visible from outside
** of this module.
@@ -973,8 +1165,8 @@ int Sqlitemultiplex_Init(Tcl_Interp *interp){
} aCmd[] = {
{ "sqlite3_multiplex_initialize", test_multiplex_initialize },
{ "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
- { "sqlite3_multiplex_set", test_multiplex_set },
{ "sqlite3_multiplex_dump", test_multiplex_dump },
+ { "sqlite3_multiplex_control", test_multiplex_control },
};
int i;
diff --git a/src/test_multiplex.h b/src/test_multiplex.h
new file mode 100644
index 000000000..ec1ba9bb2
--- /dev/null
+++ b/src/test_multiplex.h
@@ -0,0 +1,91 @@
+/*
+** 2011 March 18
+**
+** 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 multiplex system on DB files.
+** This shim shards/partitions a single DB file into smaller
+** "chunks" such that the total DB file size may exceed the maximum
+** file size of the underlying file system.
+**
+*/
+
+#ifndef _TEST_MULTIPLEX_H
+#define _TEST_MULTIPLEX_H
+
+/*
+** CAPI: File-control Operations Supported by Multiplex VFS
+**
+** Values interpreted by the xFileControl method of a Multiplex VFS db file-handle.
+**
+** MULTIPLEX_CTRL_ENABLE:
+** This file control is used to enable or disable the multiplex
+** shim.
+**
+** MULTIPLEX_CTRL_SET_CHUNK_SIZE:
+** This file control is used to set the maximum allowed chunk
+** size for a multiplex file set. The chunk size should be
+** a multiple of SQLITE_MAX_PAGE_SIZE, and will be rounded up
+** if not.
+**
+** MULTIPLEX_CTRL_SET_MAX_CHUNKS:
+** This file control is used to set the maximum number of chunks
+** allowed to be used for a mutliplex file set.
+*/
+#define MULTIPLEX_CTRL_ENABLE 214014
+#define MULTIPLEX_CTRL_SET_CHUNK_SIZE 214015
+#define MULTIPLEX_CTRL_SET_MAX_CHUNKS 214016
+
+/*
+** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
+**
+** Use the VFS named zOrigVfsName as the VFS that does the actual work.
+** Use the default if zOrigVfsName==NULL.
+**
+** The multiplex VFS shim is named "multiplex". It will become the default
+** VFS if makeDefault is non-zero.
+**
+** An auto-extension is registered which will make the function
+** multiplex_control() available to database connections. This
+** function gives access to the xFileControl interface of the
+** multiplex VFS shim.
+**
+** SELECT multiplex_control(<op>,<val>);
+**
+** <op>=1 MULTIPLEX_CTRL_ENABLE
+** <val>=0 disable
+** <val>=1 enable
+**
+** <op>=2 MULTIPLEX_CTRL_SET_CHUNK_SIZE
+** <val> int, chunk size
+**
+** <op>=3 MULTIPLEX_CTRL_SET_MAX_CHUNKS
+** <val> int, max chunks
+**
+** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once
+** during start-up.
+*/
+extern int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault);
+
+/*
+** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
+**
+** All SQLite database connections must be closed before calling this
+** routine.
+**
+** THIS ROUTINE IS NOT THREADSAFE. Call this routine exactly once while
+** shutting down in order to free all remaining multiplex groups.
+*/
+extern int sqlite3_multiplex_shutdown(void);
+
+#endif
diff --git a/src/test_syscall.c b/src/test_syscall.c
new file mode 100644
index 000000000..a757e66a5
--- /dev/null
+++ b/src/test_syscall.c
@@ -0,0 +1,654 @@
+/*
+** 2011 March 28
+**
+** 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.
+**
+*************************************************************************
+**
+** The code in this file implements a Tcl interface used to test error
+** handling in the os_unix.c module. Wrapper functions that support fault
+** injection are registered as the low-level OS functions using the
+** xSetSystemCall() method of the VFS. The Tcl interface is as follows:
+**
+**
+** test_syscall install LIST
+** Install wrapper functions for all system calls in argument LIST.
+** LIST must be a list consisting of zero or more of the following
+** literal values:
+**
+** open close access getcwd stat fstat
+** ftruncate fcntl read pread pread64 write
+** pwrite pwrite64 fchmod fallocate
+**
+** test_syscall uninstall
+** Uninstall all wrapper functions.
+**
+** test_syscall fault ?COUNT PERSIST?
+** If [test_syscall fault] is invoked without the two arguments, fault
+** injection is disabled. Otherwise, fault injection is configured to
+** cause a failure on the COUNT'th next call to a system call with a
+** wrapper function installed. A COUNT value of 1 means fail the next
+** system call.
+**
+** Argument PERSIST is interpreted as a boolean. If true, the all
+** system calls following the initial failure also fail. Otherwise, only
+** the single transient failure is injected.
+**
+** test_syscall errno CALL ERRNO
+** Set the value that the global "errno" is set to following a fault
+** in call CALL. Argument CALL must be one of the system call names
+** listed above (under [test_syscall install]). ERRNO is a symbolic
+** name (i.e. "EACCES"). Not all errno codes are supported. Add extra
+** to the aErrno table in function test_syscall_errno() below as
+** required.
+**
+** test_syscall reset ?SYSTEM-CALL?
+** With no argument, this is an alias for the [uninstall] command. However,
+** this command uses a VFS call of the form:
+**
+** xSetSystemCall(pVfs, 0, 0);
+**
+** To restore the default system calls. The [uninstall] command restores
+** each system call individually by calling (i.e.):
+**
+** xSetSystemCall(pVfs, "open", 0);
+**
+** With an argument, this command attempts to reset the system call named
+** by the parameter using the same method as [uninstall].
+**
+** test_syscall exists SYSTEM-CALL
+** Return true if the named system call exists. Or false otherwise.
+**
+** test_syscall list
+** Return a list of all system calls. The list is constructed using
+** the xNextSystemCall() VFS method.
+*/
+
+#include "sqlite3.h"
+#include "tcl.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef SQLITE_OS_UNIX
+
+/* From test1.c */
+extern const char *sqlite3TestErrorName(int);
+
+#include <sys/types.h>
+#include <errno.h>
+
+static struct TestSyscallGlobal {
+ int bPersist; /* 1 for persistent errors, 0 for transient */
+ int nCount; /* Fail after this many more calls */
+ int nFail; /* Number of failures that have occurred */
+} gSyscall = { 0, 0 };
+
+static int ts_open(const char *, int, int);
+static int ts_close(int fd);
+static int ts_access(const char *zPath, int mode);
+static char *ts_getcwd(char *zPath, size_t nPath);
+static int ts_stat(const char *zPath, struct stat *p);
+static int ts_fstat(int fd, struct stat *p);
+static int ts_ftruncate(int fd, off_t n);
+static int ts_fcntl(int fd, int cmd, ... );
+static int ts_read(int fd, void *aBuf, size_t nBuf);
+static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off);
+static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off);
+static int ts_write(int fd, const void *aBuf, size_t nBuf);
+static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off);
+static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off);
+static int ts_fchmod(int fd, mode_t mode);
+static int ts_fallocate(int fd, off_t off, off_t len);
+
+
+struct TestSyscallArray {
+ const char *zName;
+ sqlite3_syscall_ptr xTest;
+ sqlite3_syscall_ptr xOrig;
+ int default_errno; /* Default value for errno following errors */
+ int custom_errno; /* Current value for errno if error */
+} aSyscall[] = {
+ /* 0 */ { "open", (sqlite3_syscall_ptr)ts_open, 0, EACCES, 0 },
+ /* 1 */ { "close", (sqlite3_syscall_ptr)ts_close, 0, 0, 0 },
+ /* 2 */ { "access", (sqlite3_syscall_ptr)ts_access, 0, 0, 0 },
+ /* 3 */ { "getcwd", (sqlite3_syscall_ptr)ts_getcwd, 0, 0, 0 },
+ /* 4 */ { "stat", (sqlite3_syscall_ptr)ts_stat, 0, 0, 0 },
+ /* 5 */ { "fstat", (sqlite3_syscall_ptr)ts_fstat, 0, 0, 0 },
+ /* 6 */ { "ftruncate", (sqlite3_syscall_ptr)ts_ftruncate, 0, EIO, 0 },
+ /* 7 */ { "fcntl", (sqlite3_syscall_ptr)ts_fcntl, 0, EACCES, 0 },
+ /* 8 */ { "read", (sqlite3_syscall_ptr)ts_read, 0, 0, 0 },
+ /* 9 */ { "pread", (sqlite3_syscall_ptr)ts_pread, 0, 0, 0 },
+ /* 10 */ { "pread64", (sqlite3_syscall_ptr)ts_pread64, 0, 0, 0 },
+ /* 11 */ { "write", (sqlite3_syscall_ptr)ts_write, 0, 0, 0 },
+ /* 12 */ { "pwrite", (sqlite3_syscall_ptr)ts_pwrite, 0, 0, 0 },
+ /* 13 */ { "pwrite64", (sqlite3_syscall_ptr)ts_pwrite64, 0, 0, 0 },
+ /* 14 */ { "fchmod", (sqlite3_syscall_ptr)ts_fchmod, 0, 0, 0 },
+ /* 15 */ { "fallocate", (sqlite3_syscall_ptr)ts_fallocate, 0, 0, 0 },
+ { 0, 0, 0, 0, 0 }
+};
+
+#define orig_open ((int(*)(const char *, int, int))aSyscall[0].xOrig)
+#define orig_close ((int(*)(int))aSyscall[1].xOrig)
+#define orig_access ((int(*)(const char*,int))aSyscall[2].xOrig)
+#define orig_getcwd ((char*(*)(char*,size_t))aSyscall[3].xOrig)
+#define orig_stat ((int(*)(const char*,struct stat*))aSyscall[4].xOrig)
+#define orig_fstat ((int(*)(int,struct stat*))aSyscall[5].xOrig)
+#define orig_ftruncate ((int(*)(int,off_t))aSyscall[6].xOrig)
+#define orig_fcntl ((int(*)(int,int,...))aSyscall[7].xOrig)
+#define orig_read ((ssize_t(*)(int,void*,size_t))aSyscall[8].xOrig)
+#define orig_pread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].xOrig)
+#define orig_pread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].xOrig)
+#define orig_write ((ssize_t(*)(int,const void*,size_t))aSyscall[11].xOrig)
+#define orig_pwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
+ aSyscall[12].xOrig)
+#define orig_pwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
+ aSyscall[13].xOrig)
+#define orig_fchmod ((int(*)(int,mode_t))aSyscall[14].xOrig)
+#define orig_fallocate ((int(*)(int,off_t,off_t))aSyscall[15].xOrig)
+
+/*
+** This function is called exactly once from within each invocation of a
+** system call wrapper in this file. It returns 1 if the function should
+** fail, or 0 if it should succeed.
+*/
+static int tsIsFail(void){
+ gSyscall.nCount--;
+ if( gSyscall.nCount==0 || (gSyscall.nFail && gSyscall.bPersist) ){
+ gSyscall.nFail++;
+ return 1;
+ }
+ return 0;
+}
+
+/*
+** Return the current error-number value for function zFunc. zFunc must be
+** the name of a system call in the aSyscall[] table.
+**
+** Usually, the current error-number is the value that errno should be set
+** to if the named system call fails. The exception is "fallocate". See
+** comments above the implementation of ts_fallocate() for details.
+*/
+static int tsErrno(const char *zFunc){
+ int i;
+ int nFunc = strlen(zFunc);
+ for(i=0; aSyscall[i].zName; i++){
+ if( strlen(aSyscall[i].zName)!=nFunc ) continue;
+ if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
+ return aSyscall[i].custom_errno;
+ }
+
+ assert(0);
+ return 0;
+}
+
+/*
+** A wrapper around tsIsFail(). If tsIsFail() returns non-zero, set the
+** value of errno before returning.
+*/
+static int tsIsFailErrno(const char *zFunc){
+ if( tsIsFail() ){
+ errno = tsErrno(zFunc);
+ return 1;
+ }
+ return 0;
+}
+
+/*
+** A wrapper around open().
+*/
+static int ts_open(const char *zFile, int flags, int mode){
+ if( tsIsFailErrno("open") ){
+ return -1;
+ }
+ return orig_open(zFile, flags, mode);
+}
+
+/*
+** A wrapper around close().
+*/
+static int ts_close(int fd){
+ if( tsIsFail() ){
+ /* Even if simulating an error, close the original file-descriptor.
+ ** This is to stop the test process from running out of file-descriptors
+ ** when running a long test. If a call to close() appears to fail, SQLite
+ ** never attempts to use the file-descriptor afterwards (or even to close
+ ** it a second time). */
+ orig_close(fd);
+ return -1;
+ }
+ return orig_close(fd);
+}
+
+/*
+** A wrapper around access().
+*/
+static int ts_access(const char *zPath, int mode){
+ if( tsIsFail() ){
+ return -1;
+ }
+ return orig_access(zPath, mode);
+}
+
+/*
+** A wrapper around getcwd().
+*/
+static char *ts_getcwd(char *zPath, size_t nPath){
+ if( tsIsFail() ){
+ return NULL;
+ }
+ return orig_getcwd(zPath, nPath);
+}
+
+/*
+** A wrapper around stat().
+*/
+static int ts_stat(const char *zPath, struct stat *p){
+ if( tsIsFail() ){
+ return -1;
+ }
+ return orig_stat(zPath, p);
+}
+
+/*
+** A wrapper around fstat().
+*/
+static int ts_fstat(int fd, struct stat *p){
+ if( tsIsFailErrno("fstat") ){
+ return -1;
+ }
+ return orig_fstat(fd, p);
+}
+
+/*
+** A wrapper around ftruncate().
+*/
+static int ts_ftruncate(int fd, off_t n){
+ if( tsIsFailErrno("ftruncate") ){
+ return -1;
+ }
+ return orig_ftruncate(fd, n);
+}
+
+/*
+** A wrapper around fcntl().
+*/
+static int ts_fcntl(int fd, int cmd, ... ){
+ va_list ap;
+ void *pArg;
+ if( tsIsFailErrno("fcntl") ){
+ return -1;
+ }
+ va_start(ap, cmd);
+ pArg = va_arg(ap, void *);
+ return orig_fcntl(fd, cmd, pArg);
+}
+
+/*
+** A wrapper around read().
+*/
+static int ts_read(int fd, void *aBuf, size_t nBuf){
+ if( tsIsFailErrno("read") ){
+ return -1;
+ }
+ return orig_read(fd, aBuf, nBuf);
+}
+
+/*
+** A wrapper around pread().
+*/
+static int ts_pread(int fd, void *aBuf, size_t nBuf, off_t off){
+ if( tsIsFailErrno("pread") ){
+ return -1;
+ }
+ return orig_pread(fd, aBuf, nBuf, off);
+}
+
+/*
+** A wrapper around pread64().
+*/
+static int ts_pread64(int fd, void *aBuf, size_t nBuf, off_t off){
+ if( tsIsFailErrno("pread64") ){
+ return -1;
+ }
+ return orig_pread64(fd, aBuf, nBuf, off);
+}
+
+/*
+** A wrapper around write().
+*/
+static int ts_write(int fd, const void *aBuf, size_t nBuf){
+ if( tsIsFailErrno("write") ){
+ return -1;
+ }
+ return orig_write(fd, aBuf, nBuf);
+}
+
+/*
+** A wrapper around pwrite().
+*/
+static int ts_pwrite(int fd, const void *aBuf, size_t nBuf, off_t off){
+ if( tsIsFailErrno("pwrite") ){
+ return -1;
+ }
+ return orig_pwrite(fd, aBuf, nBuf, off);
+}
+
+/*
+** A wrapper around pwrite64().
+*/
+static int ts_pwrite64(int fd, const void *aBuf, size_t nBuf, off_t off){
+ if( tsIsFailErrno("pwrite64") ){
+ return -1;
+ }
+ return orig_pwrite64(fd, aBuf, nBuf, off);
+}
+
+/*
+** A wrapper around fchmod().
+*/
+static int ts_fchmod(int fd, mode_t mode){
+ if( tsIsFail() ){
+ return -1;
+ }
+ return orig_fchmod(fd, mode);
+}
+
+/*
+** A wrapper around fallocate().
+**
+** SQLite assumes that the fallocate() function is compatible with
+** posix_fallocate(). According to the Linux man page (2009-09-30):
+**
+** posix_fallocate() returns zero on success, or an error number on
+** failure. Note that errno is not set.
+*/
+static int ts_fallocate(int fd, off_t off, off_t len){
+ if( tsIsFail() ){
+ return tsErrno("fallocate");
+ }
+ return orig_fallocate(fd, off, len);
+}
+
+static int test_syscall_install(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ sqlite3_vfs *pVfs;
+ int nElem;
+ int i;
+ Tcl_Obj **apElem;
+
+ if( objc!=3 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL-LIST");
+ return TCL_ERROR;
+ }
+ if( Tcl_ListObjGetElements(interp, objv[2], &nElem, &apElem) ){
+ return TCL_ERROR;
+ }
+ pVfs = sqlite3_vfs_find(0);
+
+ for(i=0; i<nElem; i++){
+ int iCall;
+ int rc = Tcl_GetIndexFromObjStruct(interp,
+ apElem[i], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
+ );
+ if( rc ) return rc;
+ if( aSyscall[iCall].xOrig==0 ){
+ aSyscall[iCall].xOrig = pVfs->xGetSystemCall(pVfs, aSyscall[iCall].zName);
+ pVfs->xSetSystemCall(pVfs, aSyscall[iCall].zName, aSyscall[iCall].xTest);
+ }
+ aSyscall[iCall].custom_errno = aSyscall[iCall].default_errno;
+ }
+
+ return TCL_OK;
+}
+
+static int test_syscall_uninstall(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ sqlite3_vfs *pVfs;
+ int i;
+
+ if( objc!=2 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "");
+ return TCL_ERROR;
+ }
+
+ pVfs = sqlite3_vfs_find(0);
+ for(i=0; aSyscall[i].zName; i++){
+ if( aSyscall[i].xOrig ){
+ pVfs->xSetSystemCall(pVfs, aSyscall[i].zName, 0);
+ aSyscall[i].xOrig = 0;
+ }
+ }
+ return TCL_OK;
+}
+
+static int test_syscall_reset(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ sqlite3_vfs *pVfs;
+ int i;
+ int rc;
+
+ if( objc!=2 && objc!=3 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "");
+ return TCL_ERROR;
+ }
+
+ pVfs = sqlite3_vfs_find(0);
+ if( objc==2 ){
+ rc = pVfs->xSetSystemCall(pVfs, 0, 0);
+ for(i=0; aSyscall[i].zName; i++) aSyscall[i].xOrig = 0;
+ }else{
+ int nFunc;
+ char *zFunc = Tcl_GetStringFromObj(objv[2], &nFunc);
+ rc = pVfs->xSetSystemCall(pVfs, Tcl_GetString(objv[2]), 0);
+ for(i=0; rc==SQLITE_OK && aSyscall[i].zName; i++){
+ if( strlen(aSyscall[i].zName)!=nFunc ) continue;
+ if( memcmp(aSyscall[i].zName, zFunc, nFunc) ) continue;
+ aSyscall[i].xOrig = 0;
+ }
+ }
+ if( rc!=SQLITE_OK ){
+ Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3TestErrorName(rc), -1));
+ return TCL_ERROR;
+ }
+
+ Tcl_ResetResult(interp);
+ return TCL_OK;
+}
+
+static int test_syscall_exists(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ sqlite3_vfs *pVfs;
+ sqlite3_syscall_ptr x;
+
+ if( objc!=3 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "");
+ return TCL_ERROR;
+ }
+
+ pVfs = sqlite3_vfs_find(0);
+ x = pVfs->xGetSystemCall(pVfs, Tcl_GetString(objv[2]));
+
+ Tcl_SetObjResult(interp, Tcl_NewBooleanObj(x!=0));
+ return TCL_OK;
+}
+
+static int test_syscall_fault(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ int nCount = 0;
+ int bPersist = 0;
+
+ if( objc!=2 && objc!=4 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "?COUNT PERSIST?");
+ return TCL_ERROR;
+ }
+
+ if( objc==4 ){
+ if( Tcl_GetIntFromObj(interp, objv[2], &nCount)
+ || Tcl_GetBooleanFromObj(interp, objv[3], &bPersist)
+ ){
+ return TCL_ERROR;
+ }
+ }
+
+ Tcl_SetObjResult(interp, Tcl_NewIntObj(gSyscall.nFail));
+ gSyscall.nCount = nCount;
+ gSyscall.bPersist = bPersist;
+ gSyscall.nFail = 0;
+ return TCL_OK;
+}
+
+static int test_syscall_errno(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ int iCall;
+ int iErrno;
+ int rc;
+
+ struct Errno {
+ const char *z;
+ int i;
+ } aErrno[] = {
+ { "EACCES", EACCES },
+ { "EINTR", EINTR },
+ { "EIO", EIO },
+ { "EOVERFLOW", EOVERFLOW },
+ { "ENOMEM", ENOMEM },
+ { "EAGAIN", EAGAIN },
+ { "ETIMEDOUT", ETIMEDOUT },
+ { "EBUSY", EBUSY },
+ { "EPERM", EPERM },
+ { "EDEADLK", EDEADLK },
+ { "ENOLCK", ENOLCK },
+ { 0, 0 }
+ };
+
+ if( objc!=4 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "SYSCALL ERRNO");
+ return TCL_ERROR;
+ }
+
+ rc = Tcl_GetIndexFromObjStruct(interp,
+ objv[2], aSyscall, sizeof(aSyscall[0]), "system-call", 0, &iCall
+ );
+ if( rc!=TCL_OK ) return rc;
+ rc = Tcl_GetIndexFromObjStruct(interp,
+ objv[3], aErrno, sizeof(aErrno[0]), "errno", 0, &iErrno
+ );
+ if( rc!=TCL_OK ) return rc;
+
+ aSyscall[iCall].custom_errno = aErrno[iErrno].i;
+ return TCL_OK;
+}
+
+static int test_syscall_list(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ const char *zSys;
+ sqlite3_vfs *pVfs;
+ Tcl_Obj *pList;
+
+ if( objc!=2 ){
+ Tcl_WrongNumArgs(interp, 2, objv, "");
+ return TCL_ERROR;
+ }
+
+ pVfs = sqlite3_vfs_find(0);
+ pList = Tcl_NewObj();
+ Tcl_IncrRefCount(pList);
+ for(zSys = pVfs->xNextSystemCall(pVfs, 0);
+ zSys!=0;
+ zSys = pVfs->xNextSystemCall(pVfs, zSys)
+ ){
+ Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(zSys, -1));
+ }
+
+ Tcl_SetObjResult(interp, pList);
+ Tcl_DecrRefCount(pList);
+ return TCL_OK;
+}
+
+static int test_syscall(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ struct SyscallCmd {
+ const char *zName;
+ Tcl_ObjCmdProc *xCmd;
+ } aCmd[] = {
+ { "fault", test_syscall_fault },
+ { "install", test_syscall_install },
+ { "uninstall", test_syscall_uninstall },
+ { "reset", test_syscall_reset },
+ { "errno", test_syscall_errno },
+ { "exists", test_syscall_exists },
+ { "list", test_syscall_list },
+ { 0, 0 }
+ };
+ int iCmd;
+ int rc;
+
+ if( objc<2 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND ...");
+ return TCL_ERROR;
+ }
+ rc = Tcl_GetIndexFromObjStruct(interp,
+ objv[1], aCmd, sizeof(aCmd[0]), "sub-command", 0, &iCmd
+ );
+ if( rc!=TCL_OK ) return rc;
+ return aCmd[iCmd].xCmd(clientData, interp, objc, objv);
+}
+
+int SqlitetestSyscall_Init(Tcl_Interp *interp){
+ struct SyscallCmd {
+ const char *zName;
+ Tcl_ObjCmdProc *xCmd;
+ } aCmd[] = {
+ { "test_syscall", test_syscall},
+ };
+ int i;
+
+ for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
+ Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xCmd, 0, 0);
+ }
+ return TCL_OK;
+}
+#else
+int SqlitetestSyscall_Init(Tcl_Interp *interp){
+ return TCL_OK;
+}
+#endif
+
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index 36e0d260b..7cab12f78 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -559,6 +559,7 @@ void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
** the address of the next instruction to be coded.
*/
void sqlite3VdbeJumpHere(Vdbe *p, int addr){
+ assert( addr>=0 );
sqlite3VdbeChangeP2(p, addr, p->nOp);
}
@@ -1703,7 +1704,7 @@ static int vdbeCommit(sqlite3 *db, Vdbe *p){
for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
Btree *pBt = db->aDb[i].pBt;
if( pBt ){
- rc = sqlite3BtreeCommitPhaseTwo(pBt);
+ rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
}
}
if( rc==SQLITE_OK ){
@@ -1835,7 +1836,7 @@ static int vdbeCommit(sqlite3 *db, Vdbe *p){
for(i=0; i<db->nDb; i++){
Btree *pBt = db->aDb[i].pBt;
if( pBt ){
- sqlite3BtreeCommitPhaseTwo(pBt);
+ sqlite3BtreeCommitPhaseTwo(pBt, 1);
}
}
sqlite3EndBenignMalloc();
diff --git a/src/where.c b/src/where.c
index cdcaa98c0..5d8b8f4ad 100644
--- a/src/where.c
+++ b/src/where.c
@@ -2942,7 +2942,7 @@ static void bestBtreeIndex(
if( nRow>(double)1 && nEq==1 && pFirstTerm!=0 ){
if( pFirstTerm->eOperator & (WO_EQ|WO_ISNULL) ){
testcase( pFirstTerm->eOperator==WO_EQ );
- testcase( pFirstTerm->pOperator==WO_ISNULL );
+ testcase( pFirstTerm->eOperator==WO_ISNULL );
whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, &nRow);
}else if( pFirstTerm->eOperator==WO_IN && bInEst==0 ){
whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, &nRow);
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-20 12:55:49 +0000