--- generic/tclIOUtil.c.orig	Sat May 10 22:36:22 2003
+++ generic/tclIOUtil.c	Sat May 10 22:38:15 2003
@@ -488,8 +488,21 @@
  * This is protected by the cwdMutex below.
  */
 static Tcl_Obj* cwdPathPtr = NULL;
+static int cwdPathEpoch = 0;
 TCL_DECLARE_MUTEX(cwdMutex)
 
+/*
+ * This structure holds per-thread private copy of the
+ * current directory maintained by the global cwdPathPtr.
+ */
+typedef struct ThreadSpecificData {
+    int initialized;
+    int cwdPathEpoch;
+    Tcl_Obj *cwdPathPtr;
+} ThreadSpecificData;
+
+Tcl_ThreadDataKey dataKey;
+
 /* 
  * Declare fallback support function and 
  * information for Tcl_FSLoadFile 
@@ -514,21 +527,48 @@
 
 /* Now move on to the basic filesystem implementation */
 
+static void
+FsThrExitProc(cd)
+    ClientData cd;
+{
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData*)cd;
+    if (tsdPtr->cwdPathPtr != NULL) {
+	Tcl_DecrRefCount(tsdPtr->cwdPathPtr);
+    }
+}
 
 int 
 TclFSCwdPointerEquals(objPtr)
     Tcl_Obj* objPtr;
 {
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
     Tcl_MutexLock(&cwdMutex);
-    if (cwdPathPtr == objPtr) {
-	Tcl_MutexUnlock(&cwdMutex);
-	return 1;
-    } else {
-	Tcl_MutexUnlock(&cwdMutex);
-	return 0;
+    if (tsdPtr->initialized == 0) {
+	Tcl_CreateThreadExitHandler(FsThrExitProc, (ClientData)tsdPtr);
+	tsdPtr->initialized = 1;
+    }
+    if (tsdPtr->cwdPathPtr == NULL) {
+        if (cwdPathPtr == NULL) {
+    	    tsdPtr->cwdPathPtr = NULL;
+        } else {
+    	    tsdPtr->cwdPathPtr = Tcl_DuplicateObj(cwdPathPtr);
+    	    Tcl_IncrRefCount(tsdPtr->cwdPathPtr);
+        }
+	tsdPtr->cwdPathEpoch = cwdPathEpoch;
+    } else if (tsdPtr->cwdPathEpoch != cwdPathEpoch) { 
+        Tcl_DecrRefCount(tsdPtr->cwdPathPtr);
+        if (cwdPathPtr == NULL) {
+    	    tsdPtr->cwdPathPtr = NULL;
+        } else {
+    	    tsdPtr->cwdPathPtr = Tcl_DuplicateObj(cwdPathPtr);
+    	    Tcl_IncrRefCount(tsdPtr->cwdPathPtr);
+        }
     }
-}
+    Tcl_MutexUnlock(&cwdMutex);
 
+    return (tsdPtr->cwdPathPtr == objPtr); 
+}
 
 static FilesystemRecord* 
 FsGetIterator(void) {
@@ -552,6 +592,44 @@
     Tcl_MutexUnlock(&filesystemMutex);
 }
 
+static void
+FsUpdateCwd(cwdObj)
+    Tcl_Obj *cwdObj;
+{
+    int len;
+    char *str;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
+
+    if (cwdObj != NULL) {
+	str = Tcl_GetStringFromObj(cwdObj, &len);
+    }
+
+    Tcl_MutexLock(&cwdMutex);
+    if (cwdPathPtr != NULL) {
+        Tcl_DecrRefCount(cwdPathPtr);
+    }
+    if (cwdObj == NULL) {
+	cwdPathPtr = NULL;
+    } else {
+	/* This must be stored as string obj! */
+	cwdPathPtr = Tcl_NewStringObj(str, len); 
+    	Tcl_IncrRefCount(cwdPathPtr);
+    }
+    cwdPathEpoch++;
+    tsdPtr->cwdPathEpoch = cwdPathEpoch;
+    Tcl_MutexUnlock(&cwdMutex);
+
+    if (tsdPtr->cwdPathPtr) {
+        Tcl_DecrRefCount(tsdPtr->cwdPathPtr);
+    }
+    if (cwdObj == NULL) {
+	tsdPtr->cwdPathPtr = NULL;
+    } else {
+	tsdPtr->cwdPathPtr = Tcl_NewStringObj(str, len); 
+	Tcl_IncrRefCount(tsdPtr->cwdPathPtr);
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -583,6 +661,7 @@
     if (cwdPathPtr != NULL) {
 	Tcl_DecrRefCount(cwdPathPtr);
 	cwdPathPtr = NULL;
+        cwdPathEpoch = 0;
     }
 
     /* 
@@ -2203,8 +2282,10 @@
  *	should therefore ensure they only access the cwd through this
  *	function to avoid confusion.
  *	
- *	If a global cwdPathPtr already exists, it is returned, subject
- *	to a synchronisation attempt in that cwdPathPtr's fs.
+ *	If a global cwdPathPtr already exists, it is cached in the thread's
+ *	private data structures and reference to the cached copy is returned,
+ *	subject to a synchronisation attempt in that cwdPathPtr's fs.
+ *	
  *	Otherwise, the chain of functions that have been "inserted"
  *	into the filesystem will be called in succession until either a
  *	value other than NULL is returned, or the entire list is
@@ -2218,13 +2299,6 @@
  *	
  *	The result already has its refCount incremented for the caller.
  *	When it is no longer needed, that refCount should be decremented.
- *	This is needed for thread-safety purposes, to allow multiple
- *	threads to access this and related functions, while ensuring the
- *	results are always valid.
- *	
- *	Of course it is probably a bad idea for multiple threads to
- *	be *setting* the cwd anyway, but we can at least try to 
- *	help the case of multiple reads with occasional sets.
  *
  * Side effects:
  *	Various objects may be freed and allocated.
@@ -2236,7 +2310,7 @@
 Tcl_FSGetCwd(interp)
     Tcl_Interp *interp;
 {
-    Tcl_Obj *cwdToReturn;
+    ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
     
     if (TclFSCwdPointerEquals(NULL)) {
 	FilesystemRecord *fsRecPtr;
@@ -2282,14 +2356,7 @@
 		 * we'll always be in the 'else' branch below which
 		 * is simpler.
 		 */
-		Tcl_MutexLock(&cwdMutex);
-		/* Just in case the pointer has been set by another
-		 * thread between now and the test above */
-		if (cwdPathPtr != NULL) {
-		    Tcl_DecrRefCount(cwdPathPtr);
-		}
-		cwdPathPtr = norm;
-		Tcl_MutexUnlock(&cwdMutex);
+                FsUpdateCwd(norm);
 	    }
 	    Tcl_DecrRefCount(retVal);
 	}
@@ -2301,7 +2368,7 @@
 	 * allows an error to be thrown if, say, the permissions on
 	 * that directory have changed.
 	 */
-	Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(cwdPathPtr);
+	Tcl_Filesystem *fsPtr = Tcl_FSGetFileSystemForPath(tsdPtr->cwdPathPtr);
 	/* 
 	 * If the filesystem couldn't be found, or if no cwd function
 	 * exists for this filesystem, then we simply assume the cached
@@ -2324,7 +2391,7 @@
 		     */
 		    if (norm == NULL) {
 			/* Do nothing */
-		    } else if (Tcl_FSEqualPaths(cwdPathPtr, norm)) {
+		    } else if (Tcl_FSEqualPaths(tsdPtr->cwdPathPtr, norm)) {
 			/* 
 			 * If the paths were equal, we can be more
 			 * efficient and retain the old path object
@@ -2334,42 +2401,22 @@
 			 */
 			Tcl_DecrRefCount(norm);
 		    } else {
-			/* The cwd has in fact changed, so we must
-			 * lock down the cwdMutex to modify. */
-			Tcl_MutexLock(&cwdMutex);
-			Tcl_DecrRefCount(cwdPathPtr);
-			cwdPathPtr = norm;
-			Tcl_MutexUnlock(&cwdMutex);
+			FsUpdateCwd(norm);
 		    }
 		    Tcl_DecrRefCount(retVal);
 		} else {
-		    /* The 'cwd' function returned an error, so we
-		     * reset the cwd after locking down the mutex. */
-		    Tcl_MutexLock(&cwdMutex);
-		    Tcl_DecrRefCount(cwdPathPtr);
-		    cwdPathPtr = NULL;
-		    Tcl_MutexUnlock(&cwdMutex);
+		    /* The 'cwd' function returned an error; reset the cwd */
+		    FsUpdateCwd(NULL);
 		}
 	    }
 	}
     }
     
-    /* 
-     * The paths all eventually fall through to here.  Note that
-     * we use a bunch of separate mutex locks throughout this
-     * code to help prevent deadlocks between threads.  Really
-     * the only weirdness will arise if multiple threads are setting
-     * and reading the cwd, and that behaviour is always going to be
-     * a little suspect.
-     */
-    Tcl_MutexLock(&cwdMutex);
-    cwdToReturn = cwdPathPtr;
-    if (cwdToReturn != NULL) {
-	Tcl_IncrRefCount(cwdToReturn);
+    if (tsdPtr->cwdPathPtr != NULL) {
+	Tcl_IncrRefCount(tsdPtr->cwdPathPtr);
     }
-    Tcl_MutexUnlock(&cwdMutex);
     
-    return (cwdToReturn);
+    return tsdPtr->cwdPathPtr; 
 }
 
 /*
@@ -2446,20 +2493,7 @@
 	    if (normDirName == NULL) {
 	        return TCL_ERROR;
 	    }
-	    /* 
-	     * We will be adding a reference to this object when
-	     * we store it in the cwdPathPtr.
-	     */
-	    Tcl_IncrRefCount(normDirName);
-	    /* Get a lock on the cwd while we modify it */
-	    Tcl_MutexLock(&cwdMutex);
-	    /* Free up the previous cwd we stored */
-	    if (cwdPathPtr != NULL) {
-		Tcl_DecrRefCount(cwdPathPtr);
-	    }
-	    /* Now remember the current cwd */
-	    cwdPathPtr = normDirName;
-	    Tcl_MutexUnlock(&cwdMutex);
+	    FsUpdateCwd(normDirName);
 	}
     } else {
 	Tcl_SetErrno(ENOENT);
