about summary refs log tree commit diff
path: root/db2/mp/mp_fget.c
diff options
context:
space:
mode:
authorUlrich Drepper <drepper@redhat.com>1998-06-09 15:16:55 +0000
committerUlrich Drepper <drepper@redhat.com>1998-06-09 15:16:55 +0000
commitbf7997b65c7887d2acda95f5201d818a19d81711 (patch)
treeda3583de3a0b5892f90a4b1eb773a87b554ae37e /db2/mp/mp_fget.c
parent7646e67e6cc4c738a7b402c60fed39d52db0433b (diff)
downloadglibc-bf7997b65c7887d2acda95f5201d818a19d81711.tar.gz
glibc-bf7997b65c7887d2acda95f5201d818a19d81711.tar.xz
glibc-bf7997b65c7887d2acda95f5201d818a19d81711.zip
Update.
1998-06-09  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/netinet/ip.h (struct ip_options): Define
	__data member only for gcc.  Reported by ak@muc.de.

	* misc/mntent.h: Undo last patch.
	* sysdeps/unix/sysv/linux/fstatvfs.c (fstatvfs): Undo last patch.
	* misc/tst/mntent.c: Adjust code for this change.

	* io/fts.c: Updated from a slightly more recent BSD version.
	* io/fts.h: Likewise.

	* libc.map: Add __libc_stack_end.

	* db2/Makefile (routines): Add lock_region.
	* db2/config.h: Update from db-2.4.14.
	* db2/db.h: Likewise.
	* db2/db_185.h: Likewise.
	* db2/db_int.h: Likewise.
	* db2/bt_close.c: Likewise.
	* db2/bt_compare.c: Likewise.
	* db2/bt_conv.c: Likewise.
	* db2/bt_cursor.c: Likewise.
	* db2/bt_delete.c: Likewise.
	* db2/bt_open.c: Likewise.
	* db2/bt_page.c: Likewise.
	* db2/bt_put.c: Likewise.
	* db2/bt_rec.c: Likewise.
	* db2/bt_recno.c: Likewise.
	* db2/bt_rsearch.c: Likewise.
	* db2/bt_search.c: Likewise.
	* db2/bt_split.c: Likewise.
	* db2/bt_stat.c: Likewise.
	* db2/btree.src: Likewise.
	* db2/btree_auto.c: Likewise.
	* db2/getlong.c: Likewise.
	* db2/db_appinit.c: Likewise.
	* db2/db_apprec.c: Likewise.
	* db2/db_byteorder.c: Likewise.
	* db2/db_err.c: Likewise.
	* db2/db_log2.c: Likewise.
	* db2/db_region.c: Likewise.
	* db2/db_salloc.c: Likewise.
	* db2/db_shash.c: Likewise.
	* db2/db.c: Likewise.
	* db2/db.src: Likewise.
	* db2/db_auto.c: Likewise.
	* db2/db_conv.c: Likewise.
	* db2/db_dispatch.c: Likewise.
	* db2/db_dup.c: Likewise.
	* db2/db_overflow.c: Likewise.
	* db2/db_pr.c: Likewise.
	* db2/db_rec.c: Likewise.
	* db2/db_ret.c: Likewise.
	* db2/db_thread.c: Likewise.
	* db2/db185.c: Likewise.
	* db2/db185_int.h: Likewise.
	* db2/dbm.c: Likewise.
	* db2/hash.c: Likewise.
	* db2/hash.src: Likewise.
	* db2/hash_auto.c: Likewise.
	* db2/hash_conv.c: Likewise.
	* db2/hash_debug.c: Likewise.
	* db2/hash_dup.c: Likewise.
	* db2/hash_func.c: Likewise.
	* db2/hash_page.c: Likewise.
	* db2/hash_rec.c: Likewise.
	* db2/hash_stat.c: Likewise.
	* db2/btree.h: Likewise.
	* db2/btree_ext.h: Likewise.
	* db2/clib_ext.h: Likewise.
	* db2/common_ext.h: Likewise.
	* db2/cxx_int.h: Likewise.
	* db2/db.h.src: Likewise.
	* db2/db_185.h.src: Likewise.
	* db2/db_am.h: Likewise.
	* db2/db_auto.h: Likewise.
	* db2/db_cxx.h: Likewise.
	* db2/db_dispatch.h: Likewise.
	* db2/db_ext.h: Likewise.
	* db2/db_int.h.src: Likewise.
	* db2/db_page.h: Likewise.
	* db2/db_shash.h: Likewise.
	* db2/db_swap.h: Likewise.
	* db2/hash.h: Likewise.
	* db2/hash_ext.h: Likewise.
	* db2/lock.h: Likewise.
	* db2/lock_ext.h: Likewise.
	* db2/log.h: Likewise.
	* db2/log_ext.h: Likewise.
	* db2/mp.h: Likewise.
	* db2/mp_ext.h: Likewise.
	* db2/mutex_ext.h: Likewise.
	* db2/os_ext.h: Likewise.
	* db2/os_func.h: Likewise.
	* db2/queue.h: Likewise.
	* db2/shqueue.h: Likewise.
	* db2/txn.h: Likewise.
	* db2/lock.c: Likewise.
	* db2/lock_conflict.c: Likewise.
	* db2/lock_deadlock.c: Likewise.
	* db2/lock_region.c: Likewise.
	* db2/lock_util.c: Likewise.
	* db2/log.c: Likewise.
	* db2/log.src: Likewise.
	* db2/log_archive.c: Likewise.
	* db2/log_auto.c: Likewise.
	* db2/log_compare.c: Likewise.
	* db2/log_findckp.c: Likewise.
	* db2/log_get.c: Likewise.
	* db2/log_put.c: Likewise.
	* db2/log_rec.c: Likewise.
	* db2/log_register.c: Likewise.
	* db2/mp_bh.c: Likewise.
	* db2/mp_fget.c: Likewise.
	* db2/mp_fopen.c: Likewise.
	* db2/mp_fput.c: Likewise.
	* db2/mp_fset.c: Likewise.
	* db2/mp_open.c: Likewise.
	* db2/mp_pr.c: Likewise.
	* db2/mp_region.c: Likewise.
	* db2/mp_sync.c: Likewise.
	* db2/68020.gcc: Likewise.
	* db2/mutex.c: Likewise.
	* db2/parisc.gcc: Likewise.
	* db2/parisc.hp: Likewise.
	* db2/sco.cc: Likewise.
	* db2/os_abs.c: Likewise.
	* db2/os_alloc.c: Likewise.
	* db2/os_config.c: Likewise.
	* db2/os_dir.c: Likewise.
	* db2/os_fid.c: Likewise.
	* db2/os_fsync.c: Likewise.
	* db2/os_map.c: Likewise.
	* db2/os_oflags.c: Likewise.
	* db2/os_open.c: Likewise.
	* db2/os_rpath.c: Likewise.
	* db2/os_rw.c: Likewise.
	* db2/os_seek.c: Likewise.
	* db2/os_sleep.c: Likewise.
	* db2/os_spin.c: Likewise.
	* db2/os_stat.c: Likewise.
	* db2/os_unlink.c: Likewise.
	* db2/db_archive.c: Likewise.
	* db2/db_checkpoint.c: Likewise.
	* db2/db_deadlock.c: Likewise.
	* db2/db_dump.c: Likewise.
	* db2/db_dump185.c: Likewise.
	* db2/db_load.c: Likewise.
	* db2/db_printlog.c: Likewise.
	* db2/db_recover.c: Likewise.
	* db2/db_stat.c: Likewise.
	* db2/txn.c: Likewise.
	* db2/txn.src: Likewise.
	* db2/txn_auto.c: Likewise.
	* db2/txn_rec.c: Likewise.

	* elf/rtld.c: Move definition of __libc_stack_end to ...
	* sysdeps/generic/dl-sysdep.h: ...here.

	* sysdeps/unix/sysv/linux/fstatvfs.c: Handle nodiratime option.
	* sysdeps/unix/sysv/linux/bits/statvfs.h: Define ST_NODIRATIME.
	* sysdeps/unix/sysv/linux/sys/mount.h: Define MS_NODIRATIME.

1998-06-08 21:44  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/fstatvfs.c: Handle constant option string
	from mntent correctly.

1998-06-06  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* sunrpc/Makefile (generated): Correct typo.

1998-06-04  Philip Blundell  <philb@gnu.org>

	* elf/elf.h (EM_ARM, et al.): New definitions.
	* sysdeps/arm/dl-machine.h: Update for new draft ARM ELF ABI.
Diffstat (limited to 'db2/mp/mp_fget.c')
-rw-r--r--db2/mp/mp_fget.c359
1 files changed, 185 insertions, 174 deletions
diff --git a/db2/mp/mp_fget.c b/db2/mp/mp_fget.c
index f5955c4c6f..c8ae2e9d98 100644
--- a/db2/mp/mp_fget.c
+++ b/db2/mp/mp_fget.c
@@ -1,21 +1,19 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 1997
+ * Copyright (c) 1996, 1997, 1998
  *	Sleepycat Software.  All rights reserved.
  */
 #include "config.h"
 
 #ifndef lint
-static const char sccsid[] = "@(#)mp_fget.c	10.33 (Sleepycat) 12/2/97";
+static const char sccsid[] = "@(#)mp_fget.c	10.48 (Sleepycat) 6/2/98";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
 #include <sys/types.h>
-#include <sys/stat.h>
 
 #include <errno.h>
-#include <stdlib.h>
 #include <string.h>
 #endif
 
@@ -25,8 +23,6 @@ static const char sccsid[] = "@(#)mp_fget.c	10.33 (Sleepycat) 12/2/97";
 #include "mp.h"
 #include "common_ext.h"
 
-int __sleep_on_every_page_get;		/* XXX: thread debugging option. */
-
 /*
  * memp_fget --
  *	Get a page from the file.
@@ -35,7 +31,7 @@ int
 memp_fget(dbmfp, pgnoaddr, flags, addrp)
 	DB_MPOOLFILE *dbmfp;
 	db_pgno_t *pgnoaddr;
-	int flags;
+	u_int32_t flags;
 	void *addrp;
 {
 	BH *bhp;
@@ -43,11 +39,12 @@ memp_fget(dbmfp, pgnoaddr, flags, addrp)
 	MPOOL *mp;
 	MPOOLFILE *mfp;
 	size_t bucket, mf_offset;
-	u_long cnt;
-	int b_incr, b_inserted, readonly_alloc, ret;
-	void *addr;
+	u_int32_t st_hsearch;
+	int b_incr, first, ret;
 
 	dbmp = dbmfp->dbmp;
+	mp = dbmp->mp;
+	mfp = dbmfp->mfp;
 
 	/*
 	 * Validate arguments.
@@ -79,32 +76,62 @@ memp_fget(dbmfp, pgnoaddr, flags, addrp)
 		}
 	}
 
-#ifdef DEBUG
+#ifdef DIAGNOSTIC
 	/*
 	 * XXX
 	 * We want to switch threads as often as possible.  Sleep every time
 	 * we get a new page to make it more likely.
 	 */
-	if (__sleep_on_every_page_get &&
+	if (DB_GLOBAL(db_pageyield) &&
 	    (__db_yield == NULL || __db_yield() != 0))
 		__db_sleep(0, 1);
 #endif
 
-	mp = dbmp->mp;
-	mfp = dbmfp->mfp;
+	/* Initialize remaining local variables. */
 	mf_offset = R_OFFSET(dbmp, mfp);
-	addr = NULL;
 	bhp = NULL;
-	b_incr = b_inserted = ret = 0;
+	st_hsearch = 0;
+	b_incr = ret = 0;
+
+	/* Determine the hash bucket where this page will live. */
+	bucket = BUCKET(mp, mf_offset, *pgnoaddr);
 
 	LOCKREGION(dbmp);
 
 	/*
-	 * If mmap'ing the file, just return a pointer.  However, if another
-	 * process has opened the file for writing since we mmap'd it, start
-	 * playing the game by their rules, i.e. everything goes through the
-	 * cache.  All pages previously returned should be safe, as long as
-	 * a locking protocol was observed.
+	 * Check for the last or last + 1 page requests.
+	 *
+	 * Examine and update the file's last_pgno value.  We don't care if
+	 * the last_pgno value immediately changes due to another thread --
+	 * at this instant in time, the value is correct.  We do increment the
+	 * current last_pgno value if the thread is asking for a new page,
+	 * however, to ensure that two threads creating pages don't get the
+	 * same one.
+	 */
+	if (LF_ISSET(DB_MPOOL_LAST | DB_MPOOL_NEW)) {
+		if (LF_ISSET(DB_MPOOL_NEW))
+			++mfp->last_pgno;
+		*pgnoaddr = mfp->last_pgno;
+		bucket = BUCKET(mp, mf_offset, mfp->last_pgno);
+
+		if (LF_ISSET(DB_MPOOL_NEW))
+			goto alloc;
+	}
+
+	/*
+	 * If mmap'ing the file and the page is not past the end of the file,
+	 * just return a pointer.
+	 *
+	 * The page may be past the end of the file, so check the page number
+	 * argument against the original length of the file.  If we previously
+	 * returned pages past the original end of the file, last_pgno will
+	 * have been updated to match the "new" end of the file, and checking
+	 * against it would return pointers past the end of the mmap'd region.
+	 *
+	 * If another process has opened the file for writing since we mmap'd
+	 * it, we will start playing the game by their rules, i.e. everything
+	 * goes through the cache.  All pages previously returned will be safe,
+	 * as long as the correct locking protocol was observed.
 	 *
 	 * XXX
 	 * We don't discard the map because we don't know when all of the
@@ -112,203 +139,180 @@ memp_fget(dbmfp, pgnoaddr, flags, addrp)
 	 * It would be possible to do so by reference counting the open
 	 * pages from the mmap, but it's unclear to me that it's worth it.
 	 */
-	if (dbmfp->addr != NULL && F_ISSET(dbmfp->mfp, MP_CAN_MMAP)) {
-		readonly_alloc = 0;
-		if (LF_ISSET(DB_MPOOL_LAST))
-			*pgnoaddr = mfp->last_pgno;
-		else {
+	if (dbmfp->addr != NULL && F_ISSET(mfp, MP_CAN_MMAP))
+		if (*pgnoaddr > mfp->orig_last_pgno) {
 			/*
 			 * !!!
-			 * Allocate a page that can never really exist.  See
-			 * the comment above about non-existent pages and the
-			 * hash access method.
+			 * See the comment above about non-existent pages and
+			 * the hash access method.
 			 */
-			if (LF_ISSET(DB_MPOOL_CREATE | DB_MPOOL_NEW))
-				readonly_alloc = 1;
-			else if (*pgnoaddr > mfp->last_pgno) {
+			if (!LF_ISSET(DB_MPOOL_CREATE)) {
 				__db_err(dbmp->dbenv,
 				    "%s: page %lu doesn't exist",
 				    __memp_fn(dbmfp), (u_long)*pgnoaddr);
 				ret = EINVAL;
 				goto err;
 			}
-		}
-		if (!readonly_alloc) {
-			addr = R_ADDR(dbmfp, *pgnoaddr * mfp->stat.st_pagesize);
-
+		} else {
+			*(void **)addrp =
+			    R_ADDR(dbmfp, *pgnoaddr * mfp->stat.st_pagesize);
 			++mp->stat.st_map;
 			++mfp->stat.st_map;
+			goto done;
+		}
 
-			goto mapret;
+	/* Search the hash chain for the page. */
+	for (bhp = SH_TAILQ_FIRST(&dbmp->htab[bucket], __bh);
+	    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, hq, __bh)) {
+		++st_hsearch;
+		if (bhp->pgno != *pgnoaddr || bhp->mf_offset != mf_offset)
+			continue;
+
+		/* Increment the reference count. */
+		if (bhp->ref == UINT16_T_MAX) {
+			__db_err(dbmp->dbenv,
+			    "%s: page %lu: reference count overflow",
+			    __memp_fn(dbmfp), (u_long)bhp->pgno);
+			ret = EINVAL;
+			goto err;
 		}
-	}
 
-	/* Check if requesting the last page or a new page. */
-	if (LF_ISSET(DB_MPOOL_LAST))
-		*pgnoaddr = mfp->last_pgno;
+		/*
+		 * Increment the reference count.  We may discard the region
+		 * lock as we evaluate and/or read the buffer, so we need to
+		 * ensure that it doesn't move and that its contents remain
+		 * unchanged.
+		 */
+		++bhp->ref;
+		b_incr = 1;
 
-	if (LF_ISSET(DB_MPOOL_NEW)) {
-		*pgnoaddr = mfp->last_pgno + 1;
-		goto alloc;
-	}
+		/*
+	 	 * Any buffer we find might be trouble.
+		 *
+		 * BH_LOCKED --
+		 * I/O is in progress.  Because we've incremented the buffer
+		 * reference count, we know the buffer can't move.  Unlock
+		 * the region lock, wait for the I/O to complete, and reacquire
+		 * the region.
+		 */
+		for (first = 1; F_ISSET(bhp, BH_LOCKED); first = 0) {
+			UNLOCKREGION(dbmp);
 
-	/* Check the BH hash bucket queue. */
-	bucket = BUCKET(mp, mf_offset, *pgnoaddr);
-	for (cnt = 0,
-	    bhp = SH_TAILQ_FIRST(&dbmp->htab[bucket], __bh);
-	    bhp != NULL; bhp = SH_TAILQ_NEXT(bhp, hq, __bh)) {
-		++cnt;
-		if (bhp->pgno == *pgnoaddr && bhp->mf_offset == mf_offset) {
-			addr = bhp->buf;
-			++mp->stat.st_hash_searches;
-			if (cnt > mp->stat.st_hash_longest)
-				mp->stat.st_hash_longest = cnt;
-			mp->stat.st_hash_examined += cnt;
-			goto found;
+			/*
+			 * Explicitly yield the processor if it's not the first
+			 * pass through this loop -- if we don't, we might end
+			 * up running to the end of our CPU quantum as we will
+			 * simply be swapping between the two locks.
+			 */
+			if (!first && (__db_yield == NULL || __db_yield() != 0))
+				__db_sleep(0, 1);
+
+			LOCKBUFFER(dbmp, bhp);
+			/* Wait for I/O to finish... */
+			UNLOCKBUFFER(dbmp, bhp);
+			LOCKREGION(dbmp);
 		}
-	}
-	if (cnt != 0) {
-		++mp->stat.st_hash_searches;
-		if (cnt > mp->stat.st_hash_longest)
-			mp->stat.st_hash_longest = cnt;
-		mp->stat.st_hash_examined += cnt;
+
+		/*
+		 * BH_TRASH --
+		 * The contents of the buffer are garbage.  Shouldn't happen,
+		 * and this read is likely to fail, but might as well try.
+		 */
+		if (F_ISSET(bhp, BH_TRASH))
+			goto reread;
+
+		/*
+		 * BH_CALLPGIN --
+		 * The buffer was converted so it could be written, and the
+		 * contents need to be converted again.
+		 */
+		if (F_ISSET(bhp, BH_CALLPGIN)) {
+			if ((ret = __memp_pg(dbmfp, bhp, 1)) != 0)
+				goto err;
+			F_CLR(bhp, BH_CALLPGIN);
+		}
+
+		++mp->stat.st_cache_hit;
+		++mfp->stat.st_cache_hit;
+		*(void **)addrp = bhp->buf;
+		goto done;
 	}
 
-alloc:	/*
-	 * Allocate a new buffer header and data space, and mark the contents
-	 * as useless.
-	 */
+alloc:	/* Allocate new buffer header and data space. */
 	if ((ret = __memp_ralloc(dbmp, sizeof(BH) -
 	    sizeof(u_int8_t) + mfp->stat.st_pagesize, NULL, &bhp)) != 0)
 		goto err;
-	addr = bhp->buf;
-#ifdef DEBUG
-	if ((ALIGNTYPE)addr & (sizeof(size_t) - 1)) {
+
+#ifdef DIAGNOSTIC
+	if ((ALIGNTYPE)bhp->buf & (sizeof(size_t) - 1)) {
 		__db_err(dbmp->dbenv,
 		    "Internal error: BH data NOT size_t aligned.");
-		abort();
+		ret = EINVAL;
+		goto err;
 	}
 #endif
+	/* Initialize the BH fields. */
 	memset(bhp, 0, sizeof(BH));
 	LOCKINIT(dbmp, &bhp->mutex);
+	bhp->ref = 1;
+	bhp->pgno = *pgnoaddr;
+	bhp->mf_offset = mf_offset;
 
 	/*
 	 * Prepend the bucket header to the head of the appropriate MPOOL
 	 * bucket hash list.  Append the bucket header to the tail of the
 	 * MPOOL LRU chain.
-	 *
-	 * We have to do this before we read in the page so we can discard
-	 * our region lock without screwing up the world.
 	 */
-	bucket = BUCKET(mp, mf_offset, *pgnoaddr);
 	SH_TAILQ_INSERT_HEAD(&dbmp->htab[bucket], bhp, hq, __bh);
 	SH_TAILQ_INSERT_TAIL(&mp->bhq, bhp, q);
-	++mp->stat.st_page_clean;
-	b_inserted = 1;
-
-	/* Set the page number, and associated MPOOLFILE. */
-	bhp->mf_offset = mf_offset;
-	bhp->pgno = *pgnoaddr;
 
 	/*
-	 * If we know we created the page, zero it out and continue.
+	 * If we created the page, zero it out and continue.
 	 *
 	 * !!!
-	 * Note: DB_MPOOL_NEW deliberately doesn't call the pgin function.
+	 * Note: DB_MPOOL_NEW specifically doesn't call the pgin function.
 	 * If DB_MPOOL_CREATE is used, then the application's pgin function
 	 * has to be able to handle pages of 0's -- if it uses DB_MPOOL_NEW,
 	 * it can detect all of its page creates, and not bother.
 	 *
 	 * Otherwise, read the page into memory, optionally creating it if
 	 * DB_MPOOL_CREATE is set.
-	 *
-	 * Increment the reference count for created buffers, but importantly,
-	 * increment the reference count for buffers we're about to read so
-	 * that the buffer can't move.
 	 */
-	++bhp->ref;
-	b_incr = 1;
+	if (LF_ISSET(DB_MPOOL_NEW)) {
+		if (mfp->clear_len == 0)
+			memset(bhp->buf, 0, mfp->stat.st_pagesize);
+		else {
+			memset(bhp->buf, 0, mfp->clear_len);
+#ifdef DIAGNOSTIC
+			memset(bhp->buf + mfp->clear_len, 0xff,
+			    mfp->stat.st_pagesize - mfp->clear_len);
+#endif
+		}
 
-	if (LF_ISSET(DB_MPOOL_NEW))
-		memset(addr, 0, mfp->stat.st_pagesize);
-	else {
+		++mp->stat.st_page_create;
+		++mfp->stat.st_page_create;
+	} else {
 		/*
 		 * It's possible for the read function to fail, which means
-		 * that we fail as well.
+		 * that we fail as well.  Note, the __memp_pgread() function
+		 * discards the region lock, so the buffer must be pinned
+		 * down so that it cannot move and its contents are unchanged.
 		 */
 reread:		if ((ret = __memp_pgread(dbmfp,
-		    bhp, LF_ISSET(DB_MPOOL_CREATE | DB_MPOOL_NEW))) != 0)
-			goto err;
-
-		/*
-		 * !!!
-		 * The __memp_pgread call discarded and reacquired the region
-		 * lock.  Because the buffer reference count was incremented
-		 * before the region lock was discarded the buffer can't move
-		 * and its contents can't change.
-		 */
-		++mp->stat.st_cache_miss;
-		++mfp->stat.st_cache_miss;
-	}
-
-	if (0) {
-found:		/* Increment the reference count. */
-		if (bhp->ref == UINT16_T_MAX) {
-			__db_err(dbmp->dbenv,
-			    "%s: too many references to page %lu",
-			    __memp_fn(dbmfp), bhp->pgno);
-			ret = EINVAL;
-			goto err;
-		}
-		++bhp->ref;
-		b_incr = 1;
-
-		/*
-	 	 * Any found buffer might be trouble.
-		 *
-		 * BH_LOCKED --
-		 * I/O in progress, wait for it to finish.  Because the buffer
-		 * reference count was incremented before the region lock was
-		 * discarded we know the buffer can't move and its contents
-		 * can't change.
-		 */
-		for (cnt = 0; F_ISSET(bhp, BH_LOCKED); ++cnt) {
-			UNLOCKREGION(dbmp);
-
+		    bhp, LF_ISSET(DB_MPOOL_CREATE))) != 0) {
 			/*
-			 * Sleep so that we don't simply spin, switching locks.
-			 * (See the comment in include/mp.h.)
+			 * !!!
+			 * Discard the buffer unless another thread is waiting
+			 * on our I/O to complete.  Regardless, the header has
+			 * the BH_TRASH flag set.
 			 */
-			if (cnt != 0 &&
-			    (__db_yield == NULL || __db_yield() != 0))
-				__db_sleep(0, 1);
-
-			LOCKBUFFER(dbmp, bhp);
-			/* Waiting for I/O to finish... */
-			UNLOCKBUFFER(dbmp, bhp);
-			LOCKREGION(dbmp);
-		}
-
-		/*
-		 * BH_TRASH --
-		 * The buffer is garbage.
-		 */
-		if (F_ISSET(bhp, BH_TRASH))
-			goto reread;
-
-		/*
-		 * BH_CALLPGIN --
-		 * The buffer was written, and the contents need to be
-		 * converted again.
-		 */
-		if (F_ISSET(bhp, BH_CALLPGIN)) {
-			if ((ret = __memp_pg(dbmfp, bhp, 1)) != 0)
-				goto err;
-			F_CLR(bhp, BH_CALLPGIN);
+			if (bhp->ref == 1)
+				__memp_bhfree(dbmp, mfp, bhp, 1);
+			goto err;
 		}
 
-		++mp->stat.st_cache_hit;
-		++mfp->stat.st_cache_hit;
+		++mp->stat.st_cache_miss;
+		++mfp->stat.st_cache_miss;
 	}
 
 	/*
@@ -319,23 +323,30 @@ found:		/* Increment the reference count. */
 	if (bhp->pgno > mfp->last_pgno)
 		mfp->last_pgno = bhp->pgno;
 
-mapret:	LOCKHANDLE(dbmp, dbmfp->mutexp);
+	++mp->stat.st_page_clean;
+	*(void **)addrp = bhp->buf;
+
+done:	/* Update the chain search statistics. */
+	if (st_hsearch) {
+		++mp->stat.st_hash_searches;
+		if (st_hsearch > mp->stat.st_hash_longest)
+			mp->stat.st_hash_longest = st_hsearch;
+		mp->stat.st_hash_examined += st_hsearch;
+	}
+
+	UNLOCKREGION(dbmp);
+
+	LOCKHANDLE(dbmp, dbmfp->mutexp);
 	++dbmfp->pinref;
 	UNLOCKHANDLE(dbmp, dbmfp->mutexp);
 
-	if (0) {
-err:		/*
-		 * If no other process is already waiting on a created buffer,
-		 * go ahead and discard it, it's not useful.
-		 */
-		if (b_incr)
-			--bhp->ref;
-		if (b_inserted && bhp->ref == 0)
-			__memp_bhfree(dbmp, mfp, bhp, 1);
-	}
+	return (0);
 
+err:	/* Discard our reference. */
+	if (b_incr)
+		--bhp->ref;
 	UNLOCKREGION(dbmp);
 
-	*(void **)addrp = addr;
+	*(void **)addrp = NULL;
 	return (ret);
 }