Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

===================================================================
RCS file: /ftp/cvs/cvsroot/src/sys/ufs/ufs/ufs_dirhash.c,v
rcsdiff: /ftp/cvs/cvsroot/src/sys/ufs/ufs/ufs_dirhash.c,v: warning: Unknown phrases like `commitid ...;' are present.
retrieving revision 1.4.2.2
retrieving revision 1.13.2.2
diff -u -p -r1.4.2.2 -r1.13.2.2
--- src/sys/ufs/ufs/ufs_dirhash.c	2007/02/26 09:12:23	1.4.2.2
+++ src/sys/ufs/ufs/ufs_dirhash.c	2007/04/13 11:28:13	1.13.2.2
@@ -1,4 +1,4 @@
-/*	$NetBSD: ufs_dirhash.c,v 1.4.2.2 2007/02/26 09:12:23 yamt Exp $	*/
+/*	$NetBSD: ufs_dirhash.c,v 1.13.2.2 2007/04/13 11:28:13 ad Exp $	*/
 
 /*
  * Copyright (c) 2001, 2002 Ian Dowse.  All rights reserved.
@@ -75,18 +75,31 @@ static doff_t ufsdirhash_getprev(struct 
 static int ufsdirhash_recycle(int wanted);
 
 static POOL_INIT(ufsdirhash_pool, DH_NBLKOFF * sizeof(daddr_t), 0, 0, 0,
-    "ufsdirhash", &pool_allocator_nointr);
+    "ufsdirhash", &pool_allocator_nointr, IPL_NONE);
 
-#define DIRHASHLIST_LOCK()		do { } while (0)
-#define DIRHASHLIST_UNLOCK()		do { } while (0)
-#define DIRHASH_LOCK(dh)		do { } while (0)
-#define DIRHASH_UNLOCK(dh)		do { } while (0)
+#define DIRHASHLIST_LOCK()		mutex_enter(&ufsdirhash_lock)
+#define DIRHASHLIST_UNLOCK()		mutex_exit(&ufsdirhash_lock)
+#define DIRHASH_LOCK(dh)		mutex_enter(&(dh)->dh_lock)
+#define DIRHASH_UNLOCK(dh)		mutex_exit(&(dh)->dh_lock)
 #define DIRHASH_BLKALLOC_WAITOK()	pool_get(&ufsdirhash_pool, PR_WAITOK)
 #define DIRHASH_BLKFREE(ptr)		pool_put(&ufsdirhash_pool, ptr)
 
 /* Dirhash list; recently-used entries are near the tail. */
 static TAILQ_HEAD(, dirhash) ufsdirhash_list;
 
+/* Protects: ufsdirhash_list, `dh_list' field, ufs_dirhashmem. */
+static kmutex_t ufsdirhash_lock;
+
+/*
+ * Locking order:
+ *	ufsdirhash_lock
+ *	dh_lock
+ *
+ * The dh_lock mutex should be acquired either via the inode lock, or via
+ * ufsdirhash_lock. Only the owner of the inode may free the associated
+ * dirhash, but anything can steal its memory and set dh_hash to NULL.
+ */
+
 /*
  * Attempt to build up a hash table for the directory contents in
  * inode 'ip'. Returns 0 on success, or -1 of the operation failed.
@@ -163,6 +176,7 @@ ufsdirhash_build(struct inode *ip)
 		DIRHASHLIST_UNLOCK();
 		return (-1);
 	}
+	mutex_init(&dh->dh_lock, MUTEX_DEFAULT, IPL_NONE);
 	dh->dh_hash = (doff_t **)malloc(narrays * sizeof(dh->dh_hash[0]),
 	    M_DIRHASH, M_NOWAIT | M_ZERO);
 	dh->dh_blkfree = (u_int8_t *)malloc(nblocks * sizeof(dh->dh_blkfree[0]),
@@ -244,6 +258,7 @@ fail:
 	}
 	if (dh->dh_blkfree != NULL)
 		FREE(dh->dh_blkfree, M_DIRHASH);
+	mutex_destroy(&dh->dh_lock);
 	FREE(dh, M_DIRHASH);
 	ip->i_dirhash = NULL;
 	DIRHASHLIST_LOCK();
@@ -282,6 +297,7 @@ ufsdirhash_free(struct inode *ip)
 		    dh->dh_narrays * DH_NBLKOFF * sizeof(**dh->dh_hash) +
 		    dh->dh_nblk * sizeof(*dh->dh_blkfree);
 	}
+	mutex_destroy(&dh->dh_lock);
 	FREE(dh, M_DIRHASH);
 	ip->i_dirhash = NULL;
 
@@ -318,11 +334,11 @@ ufsdirhash_lookup(struct inode *ip, cons
 		return (EJUSTRETURN);
 	/*
 	 * Move this dirhash towards the end of the list if it has a
-	 * score higher than the next entry, and acquire the dh_mtx.
+	 * score higher than the next entry, and acquire the dh_lock.
 	 * Optimise the case where it's already the last by performing
 	 * an unlocked read of the TAILQ_NEXT pointer.
 	 *
-	 * In both cases, end up holding just dh_mtx.
+	 * In both cases, end up holding just dh_lock.
 	 */
 	if (TAILQ_NEXT(dh, dh_list) != NULL) {
 		DIRHASHLIST_LOCK();
@@ -400,7 +416,7 @@ restart:
 			if (ufs_blkatoff(vp, (off_t)blkoff, NULL, &bp) != 0)
 				return (EJUSTRETURN);
 		}
-		dp = (struct direct *)(bp->b_data + (offset & bmask));
+		dp = (struct direct *)((char *)bp->b_data + (offset & bmask));
 		if (dp->d_reclen == 0 || dp->d_reclen >
 		    dirblksiz - (offset & (dirblksiz - 1))) {
 			/* Corrupted directory. */
@@ -875,7 +891,7 @@ ufsdirhash_hash(struct dirhash *dh, cons
  * by the value specified by `diff'.
  *
  * The caller must ensure we have exclusive access to `dh'; normally
- * that means that dh_mtx should be held, but this is also called
+ * that means that dh_lock should be held, but this is also called
  * from ufsdirhash_build() where exclusive access can be assumed.
  */
 static void
@@ -919,6 +935,8 @@ ufsdirhash_findslot(struct dirhash *dh, 
 {
 	int slot;
 
+	KASSERT(mutex_owned(&dh->dh_lock));
+
 	/* Find the entry. */
 	KASSERT(dh->dh_hused < dh->dh_hlen);
 	slot = ufsdirhash_hash(dh, name, namelen);
@@ -941,6 +959,8 @@ ufsdirhash_delslot(struct dirhash *dh, i
 {
 	int i;
 
+	KASSERT(mutex_owned(&dh->dh_lock));
+
 	/* Mark the entry as deleted. */
 	DH_ENTRY(dh, slot) = DIRHASH_DEL;
 
@@ -1053,8 +1073,9 @@ ufsdirhash_init()
 {
 #ifdef _LKM
 	pool_init(&ufsdirhash_pool, DH_NBLKOFF * sizeof(daddr_t), 0, 0, 0,
-	    "ufsdirhash", &pool_allocator_nointr);
+	    "ufsdirhash", &pool_allocator_nointr, IPL_NONE);
 #endif
+	mutex_init(&ufsdirhash_lock, MUTEX_DEFAULT, IPL_NONE);
 	TAILQ_INIT(&ufsdirhash_list);
 }
 
@@ -1065,6 +1086,7 @@ ufsdirhash_done(void)
 #ifdef _LKM
 	pool_destroy(&ufsdirhash_pool);
 #endif
+	mutex_destroy(&ufsdirhash_lock);
 }
 
 SYSCTL_SETUP(sysctl_vfs_ufs_setup, "sysctl vfs.ufs.dirhash subtree setup")