BDB 4.1.24

9 files changed, 583 insertions, 231 deletions

diff --git a/bdb/common/db_byteorder.c b/bdb/common/db_byteorder.c
index d089cfe4c99..d42d8e6a958 100644
--- a/bdb/common/db_byteorder.c
+++ b/bdb/common/db_byteorder.c
@@ -1,30 +1,42 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ * Copyright (c) 1996-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: db_byteorder.c,v 11.4 2000/11/30 00:58:31 ubell Exp $";
+static const char revid[] = "$Id: db_byteorder.c,v 11.8 2002/02/01 18:15:29 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
 #include <sys/types.h>
-
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#if BYTE_ORDER == BIG_ENDIAN
-#define	WORDS_BIGENDIAN	1
-#endif
-#endif
-
 #endif
 
 #include "db_int.h"
-#include "common_ext.h"
+
+/*
+ * __db_isbigendian --
+ *	Return 1 if big-endian (Motorola and Sparc), not little-endian
+ *	(Intel and Vax).  We do this work at run-time, rather than at
+ *	configuration time so cross-compilation and general embedded
+ *	system support is simpler.
+ *
+ * PUBLIC: int __db_isbigendian __P((void));
+ */
+int
+__db_isbigendian()
+{
+	union {					/* From Harbison & Steele.  */
+		long l;
+		char c[sizeof(long)];
+	} u;
+
+	u.l = 1;
+	return (u.c[sizeof(long) - 1] == 1);
+}
 
 /*
  * __db_byteorder --
@@ -38,21 +50,21 @@ __db_byteorder(dbenv, lorder)
 	DB_ENV *dbenv;
 	int lorder;
 {
+	int is_bigendian;
+
+	is_bigendian = __db_isbigendian();
+
 	switch (lorder) {
 	case 0:
 		break;
 	case 1234:
-#if defined(WORDS_BIGENDIAN)
-		return (DB_SWAPBYTES);
-#else
+		if (is_bigendian)
+			return (DB_SWAPBYTES);
 		break;
-#endif
 	case 4321:
-#if defined(WORDS_BIGENDIAN)
+		if (!is_bigendian)
+			return (DB_SWAPBYTES);
 		break;
-#else
-		return (DB_SWAPBYTES);
-#endif
 	default:
 		__db_err(dbenv,
 	    "unsupported byte order, only big and little-endian supported");
diff --git a/bdb/common/db_err.c b/bdb/common/db_err.c
index d69bd023dfd..7c9ee3c4fde 100644
--- a/bdb/common/db_err.c
+++ b/bdb/common/db_err.c
@@ -1,14 +1,14 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ * Copyright (c) 1996-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: db_err.c,v 11.38 2001/01/22 21:50:25 sue Exp $";
+static const char revid[] = "$Id: db_err.c,v 11.80 2002/07/30 01:21:53 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
@@ -20,21 +20,12 @@ static const char revid[] = "$Id: db_err.c,v 11.38 2001/01/22 21:50:25 sue Exp $
 #endif
 
 #include "db_int.h"
-#include "db_shash.h"
-#include "lock.h"
-#include "lock_ext.h"
-#include "log.h"
-#include "log_ext.h"
-#include "mp.h"
-#include "mp_ext.h"
-#include "txn.h"
-#include "txn_ext.h"
-#include "clib_ext.h"
-#include "common_ext.h"
-#include "db_auto.h"
-
-static void __db_errcall __P((const DB_ENV *, int, int, const char *, va_list));
-static void __db_errfile __P((const DB_ENV *, int, int, const char *, va_list));
+#include "dbinc/db_page.h"
+#include "dbinc/db_am.h"
+#include "dbinc/db_shash.h"
+#include "dbinc/lock.h"
+#include "dbinc/log.h"
+#include "dbinc/txn.h"
 
 /*
  * __db_fchk --
@@ -89,12 +80,13 @@ __db_ferr(dbenv, name, iscombo)
  * __db_pgerr --
  *	Error when unable to retrieve a specified page.
  *
- * PUBLIC: int __db_pgerr __P((DB *, db_pgno_t));
+ * PUBLIC: void __db_pgerr __P((DB *, db_pgno_t, int));
  */
-int
-__db_pgerr(dbp, pgno)
+void
+__db_pgerr(dbp, pgno, errval)
 	DB *dbp;
 	db_pgno_t pgno;
+	int errval;
 {
 	/*
 	 * Three things are certain:
@@ -103,23 +95,22 @@ __db_pgerr(dbp, pgno)
 	 */
 	__db_err(dbp->dbenv,
 	    "unable to create/retrieve page %lu", (u_long)pgno);
-	return (__db_panic(dbp->dbenv, EIO));
+	(void)__db_panic(dbp->dbenv, errval);
 }
 
 /*
  * __db_pgfmt --
  *	Error when a page has the wrong format.
  *
- * PUBLIC: int __db_pgfmt __P((DB *, db_pgno_t));
+ * PUBLIC: int __db_pgfmt __P((DB_ENV *, db_pgno_t));
  */
 int
-__db_pgfmt(dbp, pgno)
-	DB *dbp;
+__db_pgfmt(dbenv, pgno)
+	DB_ENV *dbenv;
 	db_pgno_t pgno;
 {
-	__db_err(dbp->dbenv,
-	    "page %lu: illegal page type or format", (u_long)pgno);
-	return (__db_panic(dbp->dbenv, EINVAL));
+	__db_err(dbenv, "page %lu: illegal page type or format", (u_long)pgno);
+	return (__db_panic(dbenv, EINVAL));
 }
 
 /*
@@ -157,7 +148,7 @@ __db_assert(failedexpr, file, line)
 	(void)fprintf(stderr,
 	    "__db_assert: \"%s\" failed: file \"%s\", line %d\n",
 	    failedexpr, file, line);
-	fflush(stderr);
+	(void)fflush(stderr);
 
 	/* We want a stack trace of how this could possibly happen. */
 	abort();
@@ -176,7 +167,7 @@ int
 __db_panic_msg(dbenv)
 	DB_ENV *dbenv;
 {
-	__db_err(dbenv, "region error detected; run recovery.");
+	__db_err(dbenv, "fatal region error detected; run recovery");
 	return (DB_RUNRECOVERY);
 }
 
@@ -191,11 +182,10 @@ __db_panic(dbenv, errval)
 	DB_ENV *dbenv;
 	int errval;
 {
-
 	if (dbenv != NULL) {
-		((REGENV *)((REGINFO *)dbenv->reginfo)->primary)->panic = 1;
+		PANIC_SET(dbenv, 1);
 
-		dbenv->db_panic = errval;
+		dbenv->panic_errval = errval;
 
 		__db_err(dbenv, "PANIC: %s", db_strerror(errval));
 
@@ -203,6 +193,17 @@ __db_panic(dbenv, errval)
 			dbenv->db_paniccall(dbenv, errval);
 	}
 
+#if defined(DIAGNOSTIC) && !defined(CONFIG_TEST)
+	/*
+	 * We want a stack trace of how this could possibly happen.
+	 *
+	 * Don't drop core if it's the test suite -- it's reasonable for the
+	 * test suite to check to make sure that DB_RUNRECOVERY is returned
+	 * under certain conditions.
+	 */
+	abort();
+#endif
+
 	/*
 	 * Chaos reigns within.
 	 * Reflect, repent, and reboot.
@@ -214,6 +215,8 @@ __db_panic(dbenv, errval)
 /*
  * db_strerror --
  *	ANSI C strerror(3) for DB.
+ *
+ * EXTERN: char *db_strerror __P((int));
  */
 char *
 db_strerror(error)
@@ -232,8 +235,8 @@ db_strerror(error)
 	 * altered.
 	 */
 	switch (error) {
-	case DB_INCOMPLETE:
-		return ("DB_INCOMPLETE: Cache flush was unable to complete");
+	case DB_DONOTINDEX:
+		return ("DB_DONOTINDEX: Secondary index callback returns null");
 	case DB_KEYEMPTY:
 		return ("DB_KEYEMPTY: Non-existent key/data pair");
 	case DB_KEYEXIST:
@@ -253,8 +256,26 @@ db_strerror(error)
 		return ("DB_NOTFOUND: No matching key/data pair found");
 	case DB_OLD_VERSION:
 		return ("DB_OLDVERSION: Database requires a version upgrade");
+	case DB_PAGE_NOTFOUND:
+		return ("DB_PAGE_NOTFOUND: Requested page not found");
+	case DB_REP_DUPMASTER:
+		return ("DB_REP_DUPMASTER: A second master site appeared");
+	case DB_REP_HOLDELECTION:
+		return ("DB_REP_HOLDELECTION: Need to hold an election");
+	case DB_REP_NEWMASTER:
+		return ("DB_REP_NEWMASTER: A new master has declared itself");
+	case DB_REP_NEWSITE:
+		return ("DB_REP_NEWSITE: A new site has entered the system");
+	case DB_REP_OUTDATED:
+		return
+		    ("DB_REP_OUTDATED: Insufficient logs on master to recover");
+	case DB_REP_UNAVAIL:
+		return ("DB_REP_UNAVAIL: Unable to elect a master");
 	case DB_RUNRECOVERY:
 		return ("DB_RUNRECOVERY: Fatal error, run database recovery");
+	case DB_SECONDARY_BAD:
+		return
+	    ("DB_SECONDARY_BAD: Secondary index item missing from primary");
 	case DB_VERIFY_BAD:
 		return ("DB_VERIFY_BAD: Database verification failed");
 	default: {
@@ -274,8 +295,8 @@ db_strerror(error)
 
 /*
  * __db_err --
- *	Standard DB error routine.  The same as db_errx, except that we
- *	don't write to stderr if no output mechanism was specified.
+ *	Standard DB error routine.  The same as errx, except we don't write
+ *	to stderr if no output mechanism was specified.
  *
  * PUBLIC: void __db_err __P((const DB_ENV *, const char *, ...));
  */
@@ -289,81 +310,17 @@ __db_err(dbenv, fmt, va_alist)
 	va_dcl
 #endif
 {
-	va_list ap;
-
-/*
-	XXX
-	Log the message.
-
-	It would be nice to automatically log the error into the log files
-	if the application is configured for logging.  The problem is that
-	if we currently hold the log region mutex, we will self-deadlock.
-	Leave all the structure in place, but turned off.  I'd like to fix
-	this in the future by detecting if we have the log region already
-	locked (e.g., a flag in the environment handle), or perhaps even
-	have a finer granularity so that the only calls to __db_err we
-	can't log are those made while we have the current log buffer
-	locked, or perhaps have a separate buffer into which we log error
-	messages.
-
-#ifdef __STDC__
-	va_start(ap, fmt);
-#else
-	va_start(ap);
-#endif
-	__db_real_log(dbenv, NULL, "db_err", 0, fmt, ap);
-
-	va_end(ap);
-#endif
-*/
-
-	/* Tell the application. */
-#ifdef __STDC__
-	va_start(ap, fmt);
-#else
-	va_start(ap);
-#endif
-	__db_real_err(dbenv, 0, 0, 0, fmt, ap);
-
-	va_end(ap);
-}
-
-/*
- * __db_real_err --
- *	All the DB error routines end up here.
- *
- * PUBLIC: void __db_real_err
- * PUBLIC:     __P((const DB_ENV *, int, int, int, const char *, va_list));
- */
-void
-__db_real_err(dbenv, error, error_set, stderr_default, fmt, ap)
-	const DB_ENV *dbenv;
-	int error, error_set, stderr_default;
-	const char *fmt;
-	va_list ap;
-{
-	/* Call the user's callback function, if specified. */
-	if (dbenv != NULL && dbenv->db_errcall != NULL)
-		__db_errcall(dbenv, error, error_set, fmt, ap);
-
-	/* Write to the user's file descriptor, if specified. */
-	if (dbenv != NULL && dbenv->db_errfile != NULL)
-		__db_errfile(dbenv, error, error_set, fmt, ap);
-
-	/*
-	 * If we have a default and we didn't do either of the above, write
-	 * to the default.
-	 */
-	if (stderr_default && (dbenv == NULL ||
-	    (dbenv->db_errcall == NULL && dbenv->db_errfile == NULL)))
-		__db_errfile(dbenv, error, error_set, fmt, ap);
+	DB_REAL_ERR(dbenv, 0, 0, 0, fmt);
 }
 
 /*
  * __db_errcall --
  *	Do the error message work for callback functions.
+ *
+ * PUBLIC: void __db_errcall
+ * PUBLIC:          __P((const DB_ENV *, int, int, const char *, va_list));
  */
-static void
+void
 __db_errcall(dbenv, error, error_set, fmt, ap)
 	const DB_ENV *dbenv;
 	int error, error_set;
@@ -371,27 +328,44 @@ __db_errcall(dbenv, error, error_set, fmt, ap)
 	va_list ap;
 {
 	char *p;
-	char __errbuf[2048];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
+	char errbuf[2048];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
 
-	p = __errbuf;
-	if (fmt != NULL) {
-		p += vsnprintf(__errbuf, sizeof(__errbuf), fmt, ap);
-		if (error_set) {
-			*p++ = ':';
-			*p++ = ' ';
-		}
-	}
+	p = errbuf;
+	if (fmt != NULL)
+		p += vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
 	if (error_set)
-		(void)strcpy(p, db_strerror(error));
+		p += snprintf(p,
+		    sizeof(errbuf) - (p - errbuf), ": %s", db_strerror(error));
+	/*
+	 * !!!
+	 * We're potentially manipulating strings handed us by the application,
+	 * and on systems without a real snprintf() the sprintf() calls could
+	 * have overflowed the buffer.  We can't do anything about it now, but
+	 * we don't want to return control to the application, we might have
+	 * overwritten the stack with a Trojan horse.  We're not trying to do
+	 * anything recoverable here because systems without snprintf support
+	 * are pretty rare anymore.
+	 */
+	if ((size_t)(p - errbuf) > sizeof(errbuf)) {
+		(void)fprintf(stderr,
+		    "Berkeley DB: error callback interface buffer overflow\n");
+		(void)fflush(stderr);
+
+		abort();
+		/* NOTREACHED */
+	}
 
-	dbenv->db_errcall(dbenv->db_errpfx, __errbuf);
+	dbenv->db_errcall(dbenv->db_errpfx, errbuf);
 }
 
 /*
  * __db_errfile --
  *	Do the error message work for FILE *s.
+ *
+ * PUBLIC: void __db_errfile
+ * PUBLIC:          __P((const DB_ENV *, int, int, const char *, va_list));
  */
-static void
+void
 __db_errfile(dbenv, error, error_set, fmt, ap)
 	const DB_ENV *dbenv;
 	int error, error_set;
@@ -436,48 +410,22 @@ __db_logmsg(dbenv, txnid, opname, flags, fmt, va_alist)
 	va_dcl
 #endif
 {
-	va_list ap;
-
-#ifdef __STDC__
-	va_start(ap, fmt);
-#else
-	va_start(ap);
-#endif
-	__db_real_log(dbenv, txnid, opname, flags, fmt, ap);
-
-	va_end(ap);
-}
-
-/*
- * __db_real_log --
- *	Write information into the DB log.
- *
- * PUBLIC: void __db_real_log __P((const DB_ENV *,
- * PUBLIC:     DB_TXN *, const char *, u_int32_t, const char *, va_list ap));
- */
-void
-#ifdef __STDC__
-__db_real_log(const DB_ENV *dbenv, DB_TXN *txnid,
-    const char *opname, u_int32_t flags, const char *fmt, va_list ap)
-#else
-__db_real_log(dbenv, txnid, opname, flags, fmt, ap)
-	const DB_ENV *dbenv;
-	DB_TXN *txnid;
-	const char *opname, *fmt;
-	u_int32_t flags;
-	va_list ap;
-#endif
-{
 	DBT opdbt, msgdbt;
 	DB_LSN lsn;
+	va_list ap;
 	char __logbuf[2048];	/* !!!: END OF THE STACK DON'T TRUST SPRINTF. */
 
 	if (!LOGGING_ON(dbenv))
 		return;
 
+#ifdef __STDC__
+	va_start(ap, fmt);
+#else
+	va_start(ap);
+#endif
 	memset(&opdbt, 0, sizeof(opdbt));
 	opdbt.data = (void *)opname;
-	opdbt.size = strlen(opname) + 1;
+	opdbt.size = (u_int32_t)(strlen(opname) + 1);
 
 	memset(&msgdbt, 0, sizeof(msgdbt));
 	msgdbt.data = __logbuf;
@@ -490,6 +438,8 @@ __db_real_log(dbenv, txnid, opname, flags, fmt, ap)
 	 */
 	__db_debug_log(
 	    (DB_ENV *)dbenv, txnid, &lsn, flags, &opdbt, -1, &msgdbt, NULL, 0);
+
+	va_end(ap);
 }
 
 /*
@@ -511,34 +461,119 @@ __db_unknown_flag(dbenv, routine, flag)
 /*
  * __db_unknown_type -- report internal error
  *
- * PUBLIC: int __db_unknown_type __P((DB_ENV *, char *, u_int32_t));
+ * PUBLIC: int __db_unknown_type __P((DB_ENV *, char *, DBTYPE));
  */
 int
 __db_unknown_type(dbenv, routine, type)
 	DB_ENV *dbenv;
 	char *routine;
-	u_int32_t type;
+	DBTYPE type;
 {
 	__db_err(dbenv, "%s: Unknown db type: 0x%x", routine, type);
 	DB_ASSERT(0);
 	return (EINVAL);
 }
 
-#ifdef DIAGNOSTIC
 /*
- * __db_missing_txn_err --
- *	Cannot combine operations with and without transactions.
+ * __db_check_txn --
+ *	Check for common transaction errors.
  *
- * PUBLIC: #ifdef DIAGNOSTIC
- * PUBLIC: int __db_missing_txn_err __P((DB_ENV *));
- * PUBLIC: #endif
+ * PUBLIC: int __db_check_txn __P((DB *, DB_TXN *, u_int32_t, int));
  */
 int
-__db_missing_txn_err(dbenv)
-	DB_ENV *dbenv;
+__db_check_txn(dbp, txn, assoc_lid, read_op)
+	DB *dbp;
+	DB_TXN *txn;
+	u_int32_t assoc_lid;
+	int read_op;
 {
+	DB_ENV *dbenv;
+
+	dbenv = dbp->dbenv;
+
+	/*
+	 * If we are in recovery or aborting a transaction, then we
+	 * don't need to enforce the rules about dbp's not allowing
+	 * transactional operations in non-transactional dbps and
+	 * vica-versa.  This happens all the time as the dbp during
+	 * an abort may be transactional, but we undo operations
+	 * outside a transaction since we're aborting.
+	 */
+	if (IS_RECOVERING(dbenv) || F_ISSET(dbp, DB_AM_RECOVER))
+		return (0);
+
+	/*
+	 * Check for common transaction errors:
+	 *	Failure to pass a transaction handle to a DB operation
+	 *	Failure to configure the DB handle in a proper environment
+	 *	Operation on a handle whose open commit hasn't completed.
+	 *
+	 * Read operations don't require a txn even if we've used one before
+	 * with this handle, although if they do have a txn, we'd better be
+	 * prepared for it.
+	 */
+	if (txn == NULL) {
+		if (!read_op && F_ISSET(dbp, DB_AM_TXN)) {
+			__db_err(dbenv,
+    "DB handle previously used in transaction, missing transaction handle");
+			return (EINVAL);
+		}
+
+		if (dbp->cur_lid >= TXN_MINIMUM)
+			goto open_err;
+	} else {
+		if (dbp->cur_lid >= TXN_MINIMUM && dbp->cur_lid != txn->txnid)
+			goto open_err;
+
+		if (!TXN_ON(dbenv))
+			 return (__db_not_txn_env(dbenv));
+
+		if (!F_ISSET(dbp, DB_AM_TXN)) {
+			__db_err(dbenv,
+    "Transaction specified for a DB handle opened outside a transaction");
+			return (EINVAL);
+		}
+	}
+
+	/*
+	 * If dbp->associate_lid is not DB_LOCK_INVALIDID, that means we're in
+	 * the middle of a DB->associate with DB_CREATE (i.e., a secondary index
+	 * creation).
+	 *
+	 * In addition to the usual transaction rules, we need to lock out
+	 * non-transactional updates that aren't part of the associate (and
+	 * thus are using some other locker ID).
+	 *
+	 * Transactional updates should simply block;  from the time we
+	 * decide to build the secondary until commit, we'll hold a write
+	 * lock on all of its pages, so it should be safe to attempt to update
+	 * the secondary in another transaction (presumably by updating the
+	 * primary).
+	 */
+	if (!read_op && dbp->associate_lid != DB_LOCK_INVALIDID &&
+	    txn != NULL && dbp->associate_lid != assoc_lid) {
+		__db_err(dbenv,
+	    "Operation forbidden while secondary index is being created");
+		return (EINVAL);
+	}
+
+	return (0);
+open_err:
 	__db_err(dbenv,
-    "DB handle previously used in transaction, missing transaction handle.");
+	    "Transaction that opened the DB handle is still active");
+	return (EINVAL);
+}
+
+/*
+ * __db_not_txn_env --
+ *	DB handle must be in an environment that supports transactions.
+ *
+ * PUBLIC: int __db_not_txn_env __P((DB_ENV *));
+ */
+int
+__db_not_txn_env(dbenv)
+	DB_ENV *dbenv;
+{
+	__db_err(dbenv, "DB environment not configured for transactions");
 	return (EINVAL);
 }
-#endif
diff --git a/bdb/common/db_getlong.c b/bdb/common/db_getlong.c
index bead530cd94..6ba8ebfcdaa 100644
--- a/bdb/common/db_getlong.c
+++ b/bdb/common/db_getlong.c
@@ -1,14 +1,14 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ * Copyright (c) 1996-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: db_getlong.c,v 11.11 2000/12/22 19:16:04 bostic Exp $";
+static const char revid[] = "$Id: db_getlong.c,v 11.18 2002/03/28 20:13:33 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
@@ -20,7 +20,6 @@ static const char revid[] = "$Id: db_getlong.c,v 11.11 2000/12/22 19:16:04 bosti
 #endif
 
 #include "db_int.h"
-#include "clib_ext.h"
 
 /*
  * __db_getlong --
@@ -43,42 +42,40 @@ __db_getlong(dbp, progname, p, min, max, storep)
 	val = strtol(p, &end, 10);
 	if ((val == LONG_MIN || val == LONG_MAX) &&
 	    __os_get_errno() == ERANGE) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: %s\n", progname, p, strerror(ERANGE));
-			exit(1);
-		}
-		dbp->err(dbp, ERANGE, "%s", p);
+		else
+			dbp->err(dbp, ERANGE, "%s", p);
 		return (1);
 	}
 	if (p[0] == '\0' || (end[0] != '\0' && end[0] != '\n')) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: Invalid numeric argument\n", progname, p);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Invalid numeric argument", p);
+		else
+			dbp->errx(dbp, "%s: Invalid numeric argument", p);
 		return (1);
 	}
 	if (val < min) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: Less than minimum value (%ld)\n",
 			    progname, p, min);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Less than minimum value (%ld)", p, min);
+		else
+			dbp->errx(dbp,
+			    "%s: Less than minimum value (%ld)", p, min);
 		return (1);
 	}
 	if (val > max) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: Greater than maximum value (%ld)\n",
 			    progname, p, max);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Greater than maximum value (%ld)", p, max);
-		exit(1);
+		else
+			dbp->errx(dbp,
+			    "%s: Greater than maximum value (%ld)", p, max);
+		return (1);
 	}
 	*storep = val;
 	return (0);
@@ -109,31 +106,29 @@ __db_getulong(dbp, progname, p, min, max, storep)
 	__os_set_errno(0);
 	val = strtoul(p, &end, 10);
 	if (val == ULONG_MAX && __os_get_errno() == ERANGE) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: %s\n", progname, p, strerror(ERANGE));
-			exit(1);
-		}
-		dbp->err(dbp, ERANGE, "%s", p);
+		else
+			dbp->err(dbp, ERANGE, "%s", p);
 		return (1);
 	}
 	if (p[0] == '\0' || (end[0] != '\0' && end[0] != '\n')) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
 			    "%s: %s: Invalid numeric argument\n", progname, p);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Invalid numeric argument", p);
+		else
+			dbp->errx(dbp, "%s: Invalid numeric argument", p);
 		return (1);
 	}
 	if (val < min) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
-			    "%s: %s: Less than minimum value (%ld)\n",
+			    "%s: %s: Less than minimum value (%lu)\n",
 			    progname, p, min);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Less than minimum value (%ld)", p, min);
+		else
+			dbp->errx(dbp,
+			    "%s: Less than minimum value (%lu)", p, min);
 		return (1);
 	}
 
@@ -144,14 +139,14 @@ __db_getulong(dbp, progname, p, min, max, storep)
 	 * may not exist on all platforms.
 	 */
 	if (max != 0 && val > max) {
-		if (dbp == NULL) {
+		if (dbp == NULL)
 			fprintf(stderr,
-			    "%s: %s: Greater than maximum value (%ld)\n",
+			    "%s: %s: Greater than maximum value (%lu)\n",
 			    progname, p, max);
-			exit(1);
-		}
-		dbp->errx(dbp, "%s: Greater than maximum value (%ld)", p, max);
-		exit(1);
+		else
+			dbp->errx(dbp,
+			    "%s: Greater than maximum value (%lu)", p, max);
+		return (1);
 	}
 	*storep = val;
 	return (0);
diff --git a/bdb/common/db_idspace.c b/bdb/common/db_idspace.c
new file mode 100644
index 00000000000..588ffd9fca9
--- /dev/null
+++ b/bdb/common/db_idspace.c
@@ -0,0 +1,93 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: db_idspace.c,v 1.5 2002/02/01 18:15:29 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+#endif
+
+#include "db_int.h"
+
+static int __db_idcmp __P((const void *, const void *));
+
+static int
+__db_idcmp(a, b)
+	const void *a;
+	const void *b;
+{
+	u_int32_t i, j;
+
+	i = *(u_int32_t *)a;
+	j = *(u_int32_t *)b;
+
+	if (i < j)
+		return (-1);
+	else if (i > j)
+		return (1);
+	else
+		return (0);
+}
+
+/*
+ * __db_idspace --
+ *
+ * On input, minp and maxp contain the minimum and maximum valid values for
+ * the name space and on return, they contain the minimum and maximum ids
+ * available (by finding the biggest gap).
+ *
+ * PUBLIC: void __db_idspace __P((u_int32_t *, int, u_int32_t *, u_int32_t *));
+ */
+void
+__db_idspace(inuse, n, minp, maxp)
+	u_int32_t *inuse;
+	int n;
+	u_int32_t *minp, *maxp;
+{
+	int i, low;
+	u_int32_t gap, t;
+
+	/* A single locker ID is a special case. */
+	if (n == 1) {
+		/*
+		 * If the single item in use is the last one in the range,
+		 * then we've got to perform wrap which means that we set
+		 * the min to the minimum ID, which is what we came in with,
+		 * so we don't do anything.
+		 */
+		if (inuse[0] != *maxp)
+			*minp = inuse[0];
+		*maxp = inuse[0] - 1;
+		return;
+	}
+
+	gap = 0;
+	low = 0;
+	qsort(inuse, n, sizeof(u_int32_t), __db_idcmp);
+	for (i = 0; i < n - 1; i++)
+		if ((t = (inuse[i + 1] - inuse[i])) > gap) {
+			gap = t;
+			low = i;
+		}
+
+	/* Check for largest gap at the end of the space. */
+	if ((*maxp - inuse[n - 1]) + (inuse[0] - *minp) > gap) {
+		/* Do same check as we do in the n == 1 case. */
+		if (inuse[n - 1] != *maxp)
+			*minp = inuse[n - 1];
+		*maxp = inuse[0];
+	} else {
+		*minp = inuse[low];
+		*maxp = inuse[low + 1];
+	}
+}
diff --git a/bdb/common/db_log2.c b/bdb/common/db_log2.c
index 95bc69499c6..cdd87dda11d 100644
--- a/bdb/common/db_log2.c
+++ b/bdb/common/db_log2.c
@@ -1,7 +1,7 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ * Copyright (c) 1996-2002
  *	Sleepycat Software.  All rights reserved.
  */
 /*
@@ -39,7 +39,7 @@
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: db_log2.c,v 11.4 2000/02/14 02:59:41 bostic Exp $";
+static const char revid[] = "$Id: db_log2.c,v 11.7 2002/02/01 18:15:30 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
@@ -47,7 +47,6 @@ static const char revid[] = "$Id: db_log2.c,v 11.4 2000/02/14 02:59:41 bostic Ex
 #endif
 
 #include "db_int.h"
-#include "common_ext.h"
 
 /*
  * PUBLIC: u_int32_t __db_log2 __P((u_int32_t));
diff --git a/bdb/common/util_arg.c b/bdb/common/util_arg.c
new file mode 100644
index 00000000000..e034e3bd194
--- /dev/null
+++ b/bdb/common/util_arg.c
@@ -0,0 +1,126 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2001-2002
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: util_arg.c,v 1.4 2002/02/01 18:15:30 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+#endif
+
+#include "db_int.h"
+
+static char *__db_strsep __P((char **, const char *));
+
+/*
+ * __db_util_arg --
+ *	Convert a string into an argc/argv pair.
+ *
+ * PUBLIC: int __db_util_arg __P((char *, char *, int *, char ***));
+ */
+int
+__db_util_arg(arg0, str, argcp, argvp)
+	char *arg0, *str, ***argvp;
+	int *argcp;
+{
+	int n, ret;
+	char **ap, **argv;
+
+#define	MAXARGS	25
+	if ((ret =
+	    __os_malloc(NULL, (MAXARGS + 1) * sizeof(char **), &argv)) != 0)
+		return (ret);
+
+	ap = argv;
+	*ap++ = arg0;
+	for (n = 1; (*ap = __db_strsep(&str, " \t")) != NULL;)
+		if (**ap != '\0') {
+			++ap;
+			if (++n == MAXARGS)
+				break;
+		}
+	*ap = NULL;
+
+	*argcp = ap - argv;
+	*argvp = argv;
+
+	return (0);
+}
+
+/*-
+ * Copyright (c) 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * Get next token from string *stringp, where tokens are possibly-empty
+ * strings separated by characters from delim.
+ *
+ * Writes NULs into the string at *stringp to end tokens.
+ * delim need not remain constant from call to call.
+ * On return, *stringp points past the last NUL written (if there might
+ * be further tokens), or is NULL (if there are definitely no more tokens).
+ *
+ * If *stringp is NULL, strsep returns NULL.
+ */
+static char *
+__db_strsep(stringp, delim)
+	char **stringp;
+	const char *delim;
+{
+	const char *spanp;
+	int c, sc;
+	char *s, *tok;
+
+	if ((s = *stringp) == NULL)
+		return (NULL);
+	for (tok = s;;) {
+		c = *s++;
+		spanp = delim;
+		do {
+			if ((sc = *spanp++) == c) {
+				if (c == 0)
+					s = NULL;
+				else
+					s[-1] = 0;
+				*stringp = s;
+				return (tok);
+			}
+		} while (sc != 0);
+	}
+	/* NOTREACHED */
+}
diff --git a/bdb/common/util_cache.c b/bdb/common/util_cache.c
new file mode 100644
index 00000000000..5ca88665cc7
--- /dev/null
+++ b/bdb/common/util_cache.c
@@ -0,0 +1,92 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 2000-2002
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: util_cache.c,v 1.3 2002/04/04 18:50:10 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+
+/*
+ * __db_util_cache --
+ *	Compute if we have enough cache.
+ *
+ * PUBLIC: int __db_util_cache __P((DB_ENV *, DB *, u_int32_t *, int *));
+ */
+int
+__db_util_cache(dbenv, dbp, cachep, resizep)
+	DB_ENV *dbenv;
+	DB *dbp;
+	u_int32_t *cachep;
+	int *resizep;
+{
+	DBTYPE type;
+	DB_BTREE_STAT *bsp;
+	DB_HASH_STAT *hsp;
+	DB_QUEUE_STAT *qsp;
+	u_int32_t pgsize;
+	int ret;
+	void *sp;
+
+	/*
+	 * The current cache size is in cachep.  If it's insufficient, set the
+	 * the memory referenced by resizep to 1 and set cachep to the minimum
+	 * size needed.
+	 */
+	if ((ret = dbp->get_type(dbp, &type)) != 0) {
+		dbenv->err(dbenv, ret, "DB->get_type");
+		return (ret);
+	}
+
+	if ((ret = dbp->stat(dbp, &sp, DB_FAST_STAT)) != 0) {
+		dbenv->err(dbenv, ret, "DB->stat");
+		return (ret);
+	}
+
+	switch (type) {
+	case DB_QUEUE:
+		qsp = (DB_QUEUE_STAT *)sp;
+		pgsize = qsp->qs_pagesize;
+		break;
+	case DB_HASH:
+		hsp = (DB_HASH_STAT *)sp;
+		pgsize = hsp->hash_pagesize;
+		break;
+	case DB_BTREE:
+	case DB_RECNO:
+		bsp = (DB_BTREE_STAT *)sp;
+		pgsize = bsp->bt_pagesize;
+		break;
+	default:
+		dbenv->err(dbenv, ret, "unknown database type: %d", type);
+		return (EINVAL);
+	}
+	free(sp);
+
+	/*
+	 * Make sure our current cache is big enough.  We want at least
+	 * DB_MINPAGECACHE pages in the cache.
+	 */
+	if ((*cachep / pgsize) < DB_MINPAGECACHE) {
+		*resizep = 1;
+		*cachep = pgsize * DB_MINPAGECACHE;
+	} else
+		*resizep = 0;
+
+	return (0);
+}
diff --git a/bdb/common/util_log.c b/bdb/common/util_log.c
index a4743cc2cee..ae215fca64a 100644
--- a/bdb/common/util_log.c
+++ b/bdb/common/util_log.c
@@ -1,14 +1,14 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 2000
+ * Copyright (c) 2000-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: util_log.c,v 1.7 2000/11/30 00:58:31 ubell Exp $";
+static const char revid[] = "$Id: util_log.c,v 1.11 2002/02/01 18:15:30 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
@@ -31,7 +31,6 @@ static const char revid[] = "$Id: util_log.c,v 1.7 2000/11/30 00:58:31 ubell Exp
 #endif
 
 #include "db_int.h"
-#include "common_ext.h"
 
 /*
  * __db_util_logset --
@@ -46,12 +45,14 @@ __db_util_logset(progname, fname)
 {
 	FILE *fp;
 	time_t now;
+	u_int32_t id;
 
 	if ((fp = fopen(fname, "w")) == NULL)
 		goto err;
 
 	(void)time(&now);
-	fprintf(fp, "%s: %lu %s", progname, (u_long)getpid(), ctime(&now));
+	__os_id(&id);
+	fprintf(fp, "%s: %lu %s", progname, (u_long)id, ctime(&now));
 
 	if (fclose(fp) == EOF)
 		goto err;
diff --git a/bdb/common/util_sig.c b/bdb/common/util_sig.c
index 6fe0166fe64..9714427ad33 100644
--- a/bdb/common/util_sig.c
+++ b/bdb/common/util_sig.c
@@ -1,14 +1,14 @@
 /*-
  * See the file LICENSE for redistribution information.
  *
- * Copyright (c) 2000
+ * Copyright (c) 2000-2002
  *	Sleepycat Software.  All rights reserved.
  */
 
 #include "db_config.h"
 
 #ifndef lint
-static const char revid[] = "$Id: util_sig.c,v 1.3 2000/04/28 19:32:00 bostic Exp $";
+static const char revid[] = "$Id: util_sig.c,v 1.7 2002/02/02 17:04:42 bostic Exp $";
 #endif /* not lint */
 
 #ifndef NO_SYSTEM_INCLUDES
@@ -18,7 +18,6 @@ static const char revid[] = "$Id: util_sig.c,v 1.3 2000/04/28 19:32:00 bostic Ex
 #endif
 
 #include "db_int.h"
-#include "common_ext.h"
 
 static int	interrupt;
 static void	onint __P((int));
@@ -79,7 +78,7 @@ void
 __db_util_sigresend()
 {
 	/* Resend any caught signal. */
-	if (__db_util_interrupted != 0) {
+	if (interrupt != 0) {
 		(void)signal(interrupt, SIG_DFL);
 		(void)raise(interrupt);
 		/* NOTREACHED */