Index: src/os_unix.c
==================================================================
--- src/os_unix.c
+++ src/os_unix.c
@@ -484,11 +484,11 @@
 static void releaseOpenCnt(struct openCnt *pOpen){
   assert( sqlite3OsInMutex() );
   pOpen->nRef--;
   if( pOpen->nRef==0 ){
     sqlite3HashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0);
-    sqliteFree(pOpen->aPending);
+    free(pOpen->aPending);
     sqliteFree(pOpen);
   }
 }
 
 /*
@@ -579,10 +579,28 @@
 
 exit_findlockinfo:
   return rc;
 }
 
+#ifdef SQLITE_DEBUG
+/*
+** Helper function for printing out trace information from debugging
+** binaries. This returns the string represetation of the supplied
+** integer lock-type.
+*/
+static const char *locktypeName(int locktype){
+  switch( locktype ){
+  case NO_LOCK: return "NONE";
+  case SHARED_LOCK: return "SHARED";
+  case RESERVED_LOCK: return "RESERVED";
+  case PENDING_LOCK: return "PENDING";
+  case EXCLUSIVE_LOCK: return "EXCLUSIVE";
+  }
+  return "ERROR";
+}
+#endif
+
 /*
 ** If we are currently in a different thread than the thread that the
 ** unixFile argument belongs to, then transfer ownership of the unixFile
 ** over to the current thread.
 **
@@ -594,27 +612,34 @@
 ** If the unixFile is locked and an ownership is wrong, then return
 ** SQLITE_MISUSE.  Otherwise return SQLITE_OK.
 */
 #ifdef SQLITE_UNIX_THREADS
 static int transferOwnership(unixFile *pFile){
+  int rc;
   pthread_t hSelf;
   if( threadsOverrideEachOthersLocks ){
     /* Ownership transfers not needed on this system */
     return SQLITE_OK;
   }
   hSelf = pthread_self();
   if( pthread_equal(pFile->tid, hSelf) ){
     /* We are still in the same thread */
+    TRACE1("No-transfer, same thread\n");
     return SQLITE_OK;
   }
   if( pFile->locktype!=NO_LOCK ){
     /* We cannot change ownership while we are holding a lock! */
     return SQLITE_MISUSE;
   }
+  TRACE4("Transfer ownership of %d from %d to %d\n", pFile->h,pFile->tid,hSelf);
   pFile->tid = hSelf;
   releaseLockInfo(pFile->pLock);
-  return findLockInfo(pFile->h, &pFile->pLock, 0);
+  rc = findLockInfo(pFile->h, &pFile->pLock, 0);
+  TRACE5("LOCK    %d is now %s(%s,%d)\n", pFile->h,
+     locktypeName(pFile->locktype),
+     locktypeName(pFile->pLock->locktype), pFile->pLock->cnt);
+  return rc;
 }
 #else
 # define transferOwnership(X) SQLITE_OK
 #endif
 
@@ -1119,28 +1144,10 @@
   TRACE3("TEST WR-LOCK %d %d\n", pFile->h, r);
 
   return r;
 }
 
-#ifdef SQLITE_DEBUG
-/*
-** Helper function for printing out trace information from debugging
-** binaries. This returns the string represetation of the supplied
-** integer lock-type.
-*/
-static const char *locktypeName(int locktype){
-  switch( locktype ){
-  case NO_LOCK: return "NONE";
-  case SHARED_LOCK: return "SHARED";
-  case RESERVED_LOCK: return "RESERVED";
-  case PENDING_LOCK: return "PENDING";
-  case EXCLUSIVE_LOCK: return "EXCLUSIVE";
-  }
-  return "ERROR";
-}
-#endif
-
 /*
 ** Lock the file with the lock specified by parameter locktype - one
 ** of the following:
 **
 **     (1) SHARED_LOCK
@@ -1238,10 +1245,11 @@
   rc = transferOwnership(pFile);
   if( rc!=SQLITE_OK ){
     sqlite3OsLeaveMutex();
     return rc;
   }
+  pLock = pFile->pLock;
 
   /* If some thread using this PID has a lock via a different OsFile*
   ** handle that precludes the requested lock, return BUSY.
   */
   if( (pFile->locktype!=pLock->locktype && 
@@ -1437,11 +1445,11 @@
     if( pOpen->nLock==0 && pOpen->nPending>0 ){
       int i;
       for(i=0; i<pOpen->nPending; i++){
         close(pOpen->aPending[i]);
       }
-      sqliteFree(pOpen->aPending);
+      free(pOpen->aPending);
       pOpen->nPending = 0;
       pOpen->aPending = 0;
     }
   }
   sqlite3OsLeaveMutex();
@@ -1456,24 +1464,23 @@
   unixFile *id = (unixFile*)*pId;
   int rc;
 
   if( !id ) return SQLITE_OK;
   rc = unixUnlock(*pId, NO_LOCK);
-  if( rc ) return rc;
   if( id->dirfd>=0 ) close(id->dirfd);
   id->dirfd = -1;
   sqlite3OsEnterMutex();
 
-  if( id->pOpen->nLock ){
+  if( id->pOpen->nLock && rc==SQLITE_OK ){
     /* 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 pOpen->aPending.  It will be automatically closed when
     ** the last lock is cleared.
     */
     int *aNew;
     struct openCnt *pOpen = id->pOpen;
-    aNew = sqliteRealloc( pOpen->aPending, (pOpen->nPending+1)*sizeof(int) );
+    aNew = realloc( pOpen->aPending, (pOpen->nPending+1)*sizeof(int) );
     if( aNew==0 ){
       /* If a malloc fails, just leak the file descriptor */
     }else{
       pOpen->aPending = aNew;
       pOpen->aPending[pOpen->nPending] = id->h;

Index: src/test1.c
==================================================================
--- src/test1.c
+++ src/test1.c
@@ -11,11 +11,11 @@
 *************************************************************************
 ** Code for testing the printf() interface to SQLite.  This code
 ** is not included in the SQLite library.  It is used for automated
 ** testing of the SQLite library.
 **
-** $Id: test1.c,v 1.190 2006/01/15 00:13:16 drh Exp $
+** $Id: test1.c,v 1.191 2006/01/15 02:30:58 drh Exp $
 */
 #include "sqliteInt.h"
 #include "tcl.h"
 #include "os.h"
 #include <stdlib.h>
@@ -164,11 +164,11 @@
 ** behavior varies from machine to machine.  The solution used her is
 ** to test the string right after it is generated to see if it can be
 ** understood by scanf, and if not, try prepending an "0x" to see if
 ** that helps.  If nothing works, a fatal error is generated.
 */
-static int makePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
+int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p){
   sqlite3_snprintf(100, zPtr, "%p", p);
   return TCL_OK;
 }
 
 /*
@@ -2094,11 +2094,11 @@
     Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
     return TCL_ERROR;
   }
 
   if( pStmt ){
-    if( makePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
     Tcl_AppendResult(interp, zBuf, 0);
   }
   return TCL_OK;
 }
 
@@ -2151,11 +2151,11 @@
   Tcl_IncrRefCount(pTail);
   Tcl_ObjSetVar2(interp, objv[4], 0, pTail, 0);
   Tcl_DecrRefCount(pTail);
 
   if( pStmt ){
-    if( makePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
+    if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
   }
   Tcl_AppendResult(interp, zBuf, 0);
 #endif /* SQLITE_OMIT_UTF16 */
   return TCL_OK;
 }
@@ -2181,11 +2181,11 @@
   }
 
   zFilename = Tcl_GetString(objv[1]);
   rc = sqlite3_open(zFilename, &db);
   
-  if( makePointerStr(interp, zBuf, db) ) return TCL_ERROR;
+  if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
   Tcl_AppendResult(interp, zBuf, 0);
   return TCL_OK;
 }
 
 /*
@@ -2210,11 +2210,11 @@
   }
 
   zFilename = Tcl_GetByteArrayFromObj(objv[1], 0);
   rc = sqlite3_open16(zFilename, &db);
   
-  if( makePointerStr(interp, zBuf, db) ) return TCL_ERROR;
+  if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
   Tcl_AppendResult(interp, zBuf, 0);
 #endif /* SQLITE_OMIT_UTF16 */
   return TCL_OK;
 }
 
@@ -2604,11 +2604,11 @@
   rc = sqlite3OsOpenReadWrite(Tcl_GetString(objv[1]), &pFile, &dummy);
   if( rc!=SQLITE_OK ){
     Tcl_SetResult(interp, (char *)errorName(rc), TCL_STATIC);
     return TCL_ERROR;
   }
-  makePointerStr(interp, zBuf, pFile);
+  sqlite3TestMakePointerStr(interp, zBuf, pFile);
   Tcl_SetResult(interp, zBuf, 0);
   return TCL_ERROR;
 }
 
 /*

Index: src/test4.c
==================================================================
--- src/test4.c
+++ src/test4.c
@@ -9,11 +9,11 @@
 **    May you share freely, never taking more than you give.
 **
 *************************************************************************
 ** Code for testing the the SQLite library in a multithreaded environment.
 **
-** $Id: test4.c,v 1.14 2006/01/11 23:40:34 drh Exp $
+** $Id: test4.c,v 1.15 2006/01/15 02:30:58 drh Exp $
 */
 #include "sqliteInt.h"
 #include "tcl.h"
 #include "os.h"
 #if defined(OS_UNIX) && OS_UNIX==1 && defined(THREADSAFE) && THREADSAFE==1
@@ -612,10 +612,77 @@
   temp = threadset[i].db;
   threadset[i].db = threadset[j].db;
   threadset[j].db = temp;
   return TCL_OK;
 }
+
+/*
+** Usage: thread_db_get ID
+**
+** Return the database connection pointer for the given thread.  Then
+** remove the pointer from the thread itself.  Afterwards, the thread
+** can be stopped and the connection can be used by the main thread.
+*/
+static int tcl_thread_db_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+  extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  sqlite3TestMakePointerStr(interp, zBuf, threadset[i].db);
+  threadset[i].db = 0;
+  Tcl_SetResult(interp, zBuf, 0);
+  return TCL_OK;
+}
+
+/*
+** Usage: thread_stmt_get ID
+**
+** Return the database stmt pointer for the given thread.  Then
+** remove the pointer from the thread itself. 
+*/
+static int tcl_thread_stmt_get(
+  void *NotUsed,
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int argc,              /* Number of arguments */
+  const char **argv      /* Text of each argument */
+){
+  int i;
+  char zBuf[100];
+  extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
+  if( argc!=2 ){
+    Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
+       " ID", 0);
+    return TCL_ERROR;
+  }
+  i = parse_thread_id(interp, argv[1]);
+  if( i<0 ) return TCL_ERROR;
+  if( !threadset[i].busy ){
+    Tcl_AppendResult(interp, "no such thread", 0);
+    return TCL_ERROR;
+  }
+  thread_wait(&threadset[i]);
+  sqlite3TestMakePointerStr(interp, zBuf, threadset[i].pStmt);
+  threadset[i].pStmt = 0;
+  Tcl_SetResult(interp, zBuf, 0);
+  return TCL_OK;
+}
 
 /*
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetest4_Init(Tcl_Interp *interp){
@@ -633,10 +700,12 @@
      { "thread_error",      (Tcl_CmdProc*)tcl_thread_error      },
      { "thread_compile",    (Tcl_CmdProc*)tcl_thread_compile    },
      { "thread_step",       (Tcl_CmdProc*)tcl_thread_step       },
      { "thread_finalize",   (Tcl_CmdProc*)tcl_thread_finalize   },
      { "thread_swap",       (Tcl_CmdProc*)tcl_thread_swap       },
+     { "thread_db_get",     (Tcl_CmdProc*)tcl_thread_db_get     },
+     { "thread_stmt_get",   (Tcl_CmdProc*)tcl_thread_stmt_get   },
   };
   int i;
 
   for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
     Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);

ADDED   test/thread2.test
Index: test/thread2.test
==================================================================
--- test/thread2.test
+++ test/thread2.test
@@ -0,0 +1,237 @@
+# 2006 January 14
+#
+# 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 implements regression tests for SQLite library.  The
+# focus of this script is multithreading behavior
+#
+# $Id: thread2.test,v 1.1 2006/01/15 02:30:58 drh Exp $
+
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+
+# Skip this whole file if the thread testing code is not enabled
+#
+if {[llength [info command thread_step]]==0 || [sqlite3 -has-codec]} {
+  finish_test
+  return
+}
+if {![info exists threadsOverrideEachOthersLocks]} {
+  finish_test
+  return
+}
+
+# Create some data to work with
+#
+do_test thread1-1.1 {
+  execsql {
+    CREATE TABLE t1(a,b);
+    INSERT INTO t1 VALUES(1,'abcdefgh');
+    INSERT INTO t1 SELECT a+1, b||b FROM t1;
+    INSERT INTO t1 SELECT a+2, b||b FROM t1;
+    INSERT INTO t1 SELECT a+4, b||b FROM t1;
+    SELECT count(*), max(length(b)) FROM t1;
+  }
+} {8 64}
+
+# Use the thread_swap command to move the database connections between
+# threads, then verify that they still work.
+#
+do_test thread2-1.2 {
+  db close
+  thread_create A test.db
+  thread_create B test.db
+  thread_swap A B
+  thread_compile A {SELECT a FROM t1 LIMIT 1}
+  thread_result A
+} {SQLITE_OK}
+do_test thread2-1.3 {
+  thread_step A
+  thread_result A
+} {SQLITE_ROW}
+do_test thread2-1.4 {
+  thread_argv A 0
+} {1}
+do_test thread2-1.5 {
+  thread_finalize A
+  thread_result A
+} {SQLITE_OK}
+do_test thread2-1.6 {
+  thread_compile B {SELECT a FROM t1 LIMIT 1}
+  thread_result B
+} {SQLITE_OK}
+do_test thread2-1.7 {
+  thread_step B
+  thread_result B
+} {SQLITE_ROW}
+do_test thread2-1.8 {
+  thread_argv B 0
+} {1}
+do_test thread2-1.9 {
+  thread_finalize B
+  thread_result B
+} {SQLITE_OK}
+
+# Swap them again.
+#
+do_test thread2-2.2 {
+  thread_swap A B
+  thread_compile A {SELECT a FROM t1 LIMIT 1}
+  thread_result A
+} {SQLITE_OK}
+do_test thread2-2.3 {
+  thread_step A
+  thread_result A
+} {SQLITE_ROW}
+do_test thread2-2.4 {
+  thread_argv A 0
+} {1}
+do_test thread2-2.5 {
+  thread_finalize A
+  thread_result A
+} {SQLITE_OK}
+do_test thread2-2.6 {
+  thread_compile B {SELECT a FROM t1 LIMIT 1}
+  thread_result B
+} {SQLITE_OK}
+do_test thread2-2.7 {
+  thread_step B
+  thread_result B
+} {SQLITE_ROW}
+do_test thread2-2.8 {
+  thread_argv B 0
+} {1}
+do_test thread2-2.9 {
+  thread_finalize B
+  thread_result B
+} {SQLITE_OK}
+thread_halt A
+thread_halt B
+
+# Save the original (correct) value of threadsOverrideEachOthersLocks
+# so that it can be restored.  If this value is left set incorrectly, lots
+# of things will go wrong in future tests.
+#
+set orig_threadOverride $threadsOverrideEachOthersLocks
+
+# Pretend we are on a system (like RedHat9) were threads do not
+# override each others locks.
+#
+set threadsOverrideEachOthersLocks 0
+
+# Verify that we can move database connections between threads as
+# long as no locks are held.
+#
+do_test thread2-3.1 {
+  thread_create A test.db
+  set DB [thread_db_get A]
+  thread_halt A
+} {}
+do_test thread2-3.2 {
+  set STMT [sqlite3_prepare $DB {SELECT a FROM t1 LIMIT 1} -1 TAIL]
+  sqlite3_step $STMT
+} SQLITE_ROW
+do_test thread2-3.3 {
+  sqlite3_column_int $STMT 0
+} 1
+do_test thread2-3.4 {
+  sqlite3_finalize $STMT
+} SQLITE_OK
+do_test thread2-3.5 {
+  set STMT [sqlite3_prepare $DB {SELECT max(a) FROM t1} -1 TAIL]
+  sqlite3_step $STMT
+} SQLITE_ROW
+do_test thread2-3.6 {
+  sqlite3_column_int $STMT 0
+} 8
+do_test thread2-3.7 {
+  sqlite3_finalize $STMT
+} SQLITE_OK
+do_test thread2-3.8 {
+  sqlite3_close $DB
+} {SQLITE_OK}
+
+do_test thread2-3.10 {
+  thread_create A test.db
+  thread_compile A {SELECT a FROM t1 LIMIT 1}
+  thread_step A
+  thread_finalize A
+  set DB [thread_db_get A]
+  thread_halt A
+} {}
+do_test thread2-3.11 {
+  set STMT [sqlite3_prepare $DB {SELECT a FROM t1 LIMIT 1} -1 TAIL]
+  sqlite3_step $STMT
+} SQLITE_ROW
+do_test thread2-3.12 {
+  sqlite3_column_int $STMT 0
+} 1
+do_test thread2-3.13 {
+  sqlite3_finalize $STMT
+} SQLITE_OK
+do_test thread2-3.14 {
+  sqlite3_close $DB
+} SQLITE_OK
+
+do_test thread2-3.20 {
+  thread_create A test.db
+  thread_compile A {SELECT a FROM t1 LIMIT 3}
+  thread_step A
+  set STMT [thread_stmt_get A]
+  set DB [thread_db_get A]
+  thread_halt A
+} {}
+do_test thread2-3.21 {
+  sqlite3_step $STMT
+} SQLITE_ROW
+do_test thread2-3.22 {
+  sqlite3_column_int $STMT 0
+} 2
+do_test thread2-3.23 {
+  # The unlock fails here.  But because we never check the return
+  # code from sqlite3OsUnlock (because we cannot do anything about it
+  # if it fails) we do not realize that an error has occurred.
+  sqlite3_finalize $STMT
+} SQLITE_OK
+do_test thread2-3.25 {
+  sqlite3_close $DB
+} SQLITE_OK
+
+do_test thread2-3.30 {
+  thread_create A test.db
+  thread_compile A {BEGIN}
+  thread_step A
+  thread_finalize A
+  thread_compile A {SELECT a FROM t1 LIMIT 1}
+  thread_step A
+  thread_finalize A
+  set DB [thread_db_get A]
+  thread_halt A
+} {}
+do_test thread2-3.31 {
+  set STMT [sqlite3_prepare $DB {INSERT INTO t1 VALUES(99,'error')} -1 TAIL]
+  sqlite3_step $STMT
+} SQLITE_ERROR
+do_test thread2-3.32 {
+  sqlite3_finalize $STMT
+} SQLITE_MISUSE
+do_test thread2-3.33 {
+  sqlite3_close $DB
+} SQLITE_OK
+
+# VERY important to set the override flag back to its true value.
+#
+set threadsOverrideEachOthersLocks $orig_threadOverride
+
+# Also important to halt the worker threads, which are using spin
+# locks and eating away CPU cycles.
+#
+thread_halt *   
+finish_test