Import changeset

11 files changed, 3982 insertions, 0 deletions

diff --git a/bdb/log/log.c b/bdb/log/log.c
new file mode 100644
index 00000000000..69af1624824
--- /dev/null
+++ b/bdb/log/log.c
@@ -0,0 +1,653 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log.c,v 11.42 2001/01/15 16:42:37 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "log.h"
+#include "db_dispatch.h"
+#include "txn.h"
+#include "txn_auto.h"
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+static int __log_init __P((DB_ENV *, DB_LOG *));
+static int __log_recover __P((DB_LOG *));
+
+/*
+ * __log_open --
+ *	Internal version of log_open: only called from DB_ENV->open.
+ *
+ * PUBLIC: int __log_open __P((DB_ENV *));
+ */
+int
+__log_open(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_LOG *dblp;
+	LOG *lp;
+	int ret;
+	u_int8_t *readbufp;
+
+	readbufp = NULL;
+
+	/* Create/initialize the DB_LOG structure. */
+	if ((ret = __os_calloc(dbenv, 1, sizeof(DB_LOG), &dblp)) != 0)
+		return (ret);
+	if ((ret = __os_calloc(dbenv, 1, dbenv->lg_bsize, &readbufp)) != 0)
+		goto err;
+	ZERO_LSN(dblp->c_lsn);
+	dblp->dbenv = dbenv;
+
+	/* Join/create the log region. */
+	dblp->reginfo.type = REGION_TYPE_LOG;
+	dblp->reginfo.id = INVALID_REGION_ID;
+	dblp->reginfo.mode = dbenv->db_mode;
+	dblp->reginfo.flags = REGION_JOIN_OK;
+	if (F_ISSET(dbenv, DB_ENV_CREATE))
+		F_SET(&dblp->reginfo, REGION_CREATE_OK);
+	if ((ret = __db_r_attach(
+	    dbenv, &dblp->reginfo, LG_BASE_REGION_SIZE + dbenv->lg_bsize)) != 0)
+		goto err;
+
+	dblp->readbufp = readbufp;
+
+	/* If we created the region, initialize it. */
+	if (F_ISSET(&dblp->reginfo, REGION_CREATE) &&
+	    (ret = __log_init(dbenv, dblp)) != 0)
+		goto err;
+
+	/* Set the local addresses. */
+	lp = dblp->reginfo.primary =
+	    R_ADDR(&dblp->reginfo, dblp->reginfo.rp->primary);
+	dblp->bufp = R_ADDR(&dblp->reginfo, lp->buffer_off);
+
+	/*
+	 * If the region is threaded, then we have to lock both the handles
+	 * and the region, and we need to allocate a mutex for that purpose.
+	 */
+	if (F_ISSET(dbenv, DB_ENV_THREAD)) {
+		if ((ret = __db_mutex_alloc(
+		    dbenv, &dblp->reginfo, &dblp->mutexp)) != 0)
+			goto err;
+		if ((ret = __db_mutex_init(
+		    dbenv, dblp->mutexp, 0, MUTEX_THREAD)) != 0)
+			goto err;
+	}
+
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	dblp->r_file = 0;
+	dblp->r_off = 0;
+	dblp->r_size = 0;
+	dbenv->lg_handle = dblp;
+	return (0);
+
+err:	if (dblp->reginfo.addr != NULL) {
+		if (F_ISSET(&dblp->reginfo, REGION_CREATE))
+			ret = __db_panic(dbenv, ret);
+		R_UNLOCK(dbenv, &dblp->reginfo);
+		(void)__db_r_detach(dbenv, &dblp->reginfo, 0);
+	}
+
+	if (readbufp != NULL)
+		__os_free(readbufp, dbenv->lg_bsize);
+	if (dblp->mutexp != NULL)
+		__db_mutex_free(dbenv, &dblp->reginfo, dblp->mutexp);
+	__os_free(dblp, sizeof(*dblp));
+	return (ret);
+}
+
+/*
+ * __log_init --
+ *	Initialize a log region in shared memory.
+ */
+static int
+__log_init(dbenv, dblp)
+	DB_ENV *dbenv;
+	DB_LOG *dblp;
+{
+	LOG *region;
+	int ret;
+	void *p;
+
+	if ((ret = __db_shalloc(dblp->reginfo.addr,
+	    sizeof(*region), 0, &dblp->reginfo.primary)) != 0)
+		goto mem_err;
+	dblp->reginfo.rp->primary =
+	    R_OFFSET(&dblp->reginfo, dblp->reginfo.primary);
+	region = dblp->reginfo.primary;
+	memset(region, 0, sizeof(*region));
+
+	region->persist.lg_max = dbenv->lg_max;
+	region->persist.magic = DB_LOGMAGIC;
+	region->persist.version = DB_LOGVERSION;
+	region->persist.mode = dbenv->db_mode;
+	SH_TAILQ_INIT(&region->fq);
+
+	/* Initialize LOG LSNs. */
+	region->lsn.file = 1;
+	region->lsn.offset = 0;
+
+	/* Initialize the buffer. */
+	if ((ret =
+	    __db_shalloc(dblp->reginfo.addr, dbenv->lg_bsize, 0, &p)) != 0) {
+mem_err:	__db_err(dbenv, "Unable to allocate memory for the log buffer");
+		return (ret);
+	}
+	region->buffer_size = dbenv->lg_bsize;
+	region->buffer_off = R_OFFSET(&dblp->reginfo, p);
+
+	/* Try and recover any previous log files before releasing the lock. */
+	return (__log_recover(dblp));
+}
+
+/*
+ * __log_recover --
+ *	Recover a log.
+ */
+static int
+__log_recover(dblp)
+	DB_LOG *dblp;
+{
+	DBT dbt;
+	DB_LSN lsn;
+	LOG *lp;
+	int cnt, found_checkpoint, ret;
+	u_int32_t chk;
+	logfile_validity status;
+
+	lp = dblp->reginfo.primary;
+
+	/*
+	 * Find a log file.  If none exist, we simply return, leaving
+	 * everything initialized to a new log.
+	 */
+	if ((ret = __log_find(dblp, 0, &cnt, &status)) != 0)
+		return (ret);
+	if (cnt == 0)
+		return (0);
+
+	/*
+	 * If the last file is an old version, readable or no, start a new
+	 * file.  Don't bother finding checkpoints;  if we didn't take a
+	 * checkpoint right before upgrading, the user screwed up anyway.
+	 */
+	if (status == DB_LV_OLD_READABLE || status == DB_LV_OLD_UNREADABLE) {
+		lp->lsn.file = lp->s_lsn.file = cnt + 1;
+		lp->lsn.offset = lp->s_lsn.offset = 0;
+		goto skipsearch;
+	}
+	DB_ASSERT(status == DB_LV_NORMAL);
+
+	/*
+	 * We have the last useful log file and we've loaded any persistent
+	 * information.  Set the end point of the log past the end of the last
+	 * file. Read the last file, looking for the last checkpoint and
+	 * the log's end.
+	 */
+	lp->lsn.file = cnt + 1;
+	lp->lsn.offset = 0;
+	lsn.file = cnt;
+	lsn.offset = 0;
+
+	/* Set the cursor.  Shouldn't fail;  leave error messages on. */
+	memset(&dbt, 0, sizeof(dbt));
+	if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
+		return (ret);
+
+	/*
+	 * Read to the end of the file, saving checkpoints.  This will fail
+	 * at some point, so turn off error messages.
+	 */
+	found_checkpoint = 0;
+	while (__log_get(dblp, &lsn, &dbt, DB_NEXT, 1) == 0) {
+		if (dbt.size < sizeof(u_int32_t))
+			continue;
+		memcpy(&chk, dbt.data, sizeof(u_int32_t));
+		if (chk == DB_txn_ckp) {
+			lp->chkpt_lsn = lsn;
+			found_checkpoint = 1;
+		}
+	}
+
+	/*
+	 * We now know where the end of the log is.  Set the first LSN that
+	 * we want to return to an application and the LSN of the last known
+	 * record on disk.
+	 */
+	lp->lsn = lsn;
+	lp->s_lsn = lsn;
+	lp->lsn.offset += dblp->c_len;
+	lp->s_lsn.offset += dblp->c_len;
+
+	/* Set up the current buffer information, too. */
+	lp->len = dblp->c_len;
+	lp->b_off = 0;
+	lp->w_off = lp->lsn.offset;
+
+	/*
+	 * It's possible that we didn't find a checkpoint because there wasn't
+	 * one in the last log file.  Start searching.
+	 */
+	if (!found_checkpoint && cnt > 1) {
+		lsn.file = cnt;
+		lsn.offset = 0;
+
+		/* Set the cursor.  Shouldn't fail, leave error messages on. */
+		if ((ret = __log_get(dblp, &lsn, &dbt, DB_SET, 0)) != 0)
+			return (ret);
+
+		/*
+		 * Read to the end of the file, saving checkpoints.  Again,
+		 * this can fail if there are no checkpoints in any log file,
+		 * so turn error messages off.
+		 */
+		while (__log_get(dblp, &lsn, &dbt, DB_PREV, 1) == 0) {
+			if (dbt.size < sizeof(u_int32_t))
+				continue;
+			memcpy(&chk, dbt.data, sizeof(u_int32_t));
+			if (chk == DB_txn_ckp) {
+				lp->chkpt_lsn = lsn;
+				found_checkpoint = 1;
+				break;
+			}
+		}
+	}
+
+	/* If we never find a checkpoint, that's okay, just 0 it out. */
+	if (!found_checkpoint)
+skipsearch:	ZERO_LSN(lp->chkpt_lsn);
+
+	/*
+	 * Reset the cursor lsn to the beginning of the log, so that an
+	 * initial call to DB_NEXT does the right thing.
+	 */
+	ZERO_LSN(dblp->c_lsn);
+
+	if (FLD_ISSET(dblp->dbenv->verbose, DB_VERB_RECOVERY))
+		__db_err(dblp->dbenv,
+		    "Finding last valid log LSN: file: %lu offset %lu",
+		    (u_long)lp->lsn.file, (u_long)lp->lsn.offset);
+
+	return (0);
+}
+
+/*
+ * __log_find --
+ *	Try to find a log file.  If find_first is set, valp will contain
+ * the number of the first readable log file, else it will contain the number
+ * of the last log file (which may be too old to read).
+ *
+ * PUBLIC: int __log_find __P((DB_LOG *, int, int *, logfile_validity *));
+ */
+int
+__log_find(dblp, find_first, valp, statusp)
+	DB_LOG *dblp;
+	int find_first, *valp;
+	logfile_validity *statusp;
+{
+	logfile_validity clv_status, status;
+	u_int32_t clv, logval;
+	int cnt, fcnt, ret;
+	const char *dir;
+	char **names, *p, *q, savech;
+
+	clv_status = status = DB_LV_NORMAL;
+
+	/* Return a value of 0 as the log file number on failure. */
+	*valp = 0;
+
+	/* Find the directory name. */
+	if ((ret = __log_name(dblp, 1, &p, NULL, 0)) != 0)
+		return (ret);
+	if ((q = __db_rpath(p)) == NULL) {
+		COMPQUIET(savech, 0);
+		dir = PATH_DOT;
+	} else {
+		savech = *q;
+		*q = '\0';
+		dir = p;
+	}
+
+	/* Get the list of file names. */
+	ret = __os_dirlist(dblp->dbenv, dir, &names, &fcnt);
+
+	/*
+	 * !!!
+	 * We overwrote a byte in the string with a nul.  Restore the string
+	 * so that the diagnostic checks in the memory allocation code work
+	 * and any error messages display the right file name.
+	 */
+	if (q != NULL)
+		*q = savech;
+
+	if (ret != 0) {
+		__db_err(dblp->dbenv, "%s: %s", dir, db_strerror(ret));
+		__os_freestr(p);
+		return (ret);
+	}
+
+	/* Search for a valid log file name. */
+	for (cnt = fcnt, clv = logval = 0; --cnt >= 0;) {
+		if (strncmp(names[cnt], LFPREFIX, sizeof(LFPREFIX) - 1) != 0)
+			continue;
+
+		/*
+		 * Use atol, not atoi; if an "int" is 16-bits, the largest
+		 * log file name won't fit.
+		 */
+		clv = atol(names[cnt] + (sizeof(LFPREFIX) - 1));
+		if (find_first) {
+			if (logval != 0 && clv > logval)
+				continue;
+		} else
+			if (logval != 0 && clv < logval)
+				continue;
+
+		/*
+		 * Take note of whether the log file logval is
+		 * an old version or incompletely initialized.
+		 */
+		if ((ret = __log_valid(dblp, clv, 1, &status)) != 0)
+			goto err;
+		switch (status) {
+		case DB_LV_INCOMPLETE:
+			/*
+			 * It's acceptable for the last log file to
+			 * have been incompletely initialized--it's possible
+			 * to create a log file but not write anything to it,
+			 * and recovery needs to gracefully handle this.
+			 *
+			 * Just ignore it;  we don't want to return this
+			 * as a valid log file.
+			 */
+			break;
+		case DB_LV_NORMAL:
+		case DB_LV_OLD_READABLE:
+			logval = clv;
+			clv_status = status;
+			break;
+		case DB_LV_OLD_UNREADABLE:
+			/*
+			 * Continue;  we want the oldest valid log,
+			 * and clv is too old to be useful.  We don't
+			 * want it to supplant logval if we're looking for
+			 * the oldest valid log, but we do want to return
+			 * it if it's the last log file--we want the very
+			 * last file number, so that our caller can
+			 * start a new file after it.
+			 *
+			 * The code here assumes that there will never
+			 * be a too-old log that's preceded by a log
+			 * of the current version, but in order to
+			 * attain that state of affairs the user
+			 * would have had to really seriously screw
+			 * up;  I think we can safely assume this won't
+			 * happen.
+			 */
+			if (!find_first) {
+				logval = clv;
+				clv_status = status;
+			}
+			break;
+		}
+	}
+
+	*valp = logval;
+
+err:	__os_dirfree(names, fcnt);
+	__os_freestr(p);
+	*statusp = clv_status;
+
+	return (ret);
+}
+
+/*
+ * log_valid --
+ *	Validate a log file.  Returns an error code in the event of
+ *	a fatal flaw in a the specified log file;  returns success with
+ *	a code indicating the currentness and completeness of the specified
+ *	log file if it is not unexpectedly flawed (that is, if it's perfectly
+ *	normal, if it's zero-length, or if it's an old version).
+ *
+ * PUBLIC: int __log_valid __P((DB_LOG *, u_int32_t, int, logfile_validity *));
+ */
+int
+__log_valid(dblp, number, set_persist, statusp)
+	DB_LOG *dblp;
+	u_int32_t number;
+	int set_persist;
+	logfile_validity *statusp;
+{
+	DB_FH fh;
+	LOG *region;
+	LOGP persist;
+	char *fname;
+	int ret;
+	logfile_validity status;
+	size_t nw;
+
+	status = DB_LV_NORMAL;
+
+	/* Try to open the log file. */
+	if ((ret = __log_name(dblp,
+	    number, &fname, &fh, DB_OSO_RDONLY | DB_OSO_SEQ)) != 0) {
+		__os_freestr(fname);
+		return (ret);
+	}
+
+	/* Try to read the header. */
+	if ((ret =
+	    __os_seek(dblp->dbenv,
+	    &fh, 0, 0, sizeof(HDR), 0, DB_OS_SEEK_SET)) != 0 ||
+	    (ret =
+	    __os_read(dblp->dbenv, &fh, &persist, sizeof(LOGP), &nw)) != 0 ||
+	    nw != sizeof(LOGP)) {
+		if (ret == 0)
+			status = DB_LV_INCOMPLETE;
+		else
+			/*
+			 * The error was a fatal read error, not just an
+			 * incompletely initialized log file.
+			 */
+			__db_err(dblp->dbenv, "Ignoring log file: %s: %s",
+			    fname, db_strerror(ret));
+
+		(void)__os_closehandle(&fh);
+		goto err;
+	}
+	(void)__os_closehandle(&fh);
+
+	/* Validate the header. */
+	if (persist.magic != DB_LOGMAGIC) {
+		__db_err(dblp->dbenv,
+		    "Ignoring log file: %s: magic number %lx, not %lx",
+		    fname, (u_long)persist.magic, (u_long)DB_LOGMAGIC);
+		ret = EINVAL;
+		goto err;
+	}
+
+	/*
+	 * Set our status code to indicate whether the log file
+	 * belongs to an unreadable or readable old version;  leave it
+	 * alone if and only if the log file version is the current one.
+	 */
+	if (persist.version > DB_LOGVERSION) {
+		/* This is a fatal error--the log file is newer than DB. */
+		__db_err(dblp->dbenv,
+		    "Ignoring log file: %s: unsupported log version %lu",
+		    fname, (u_long)persist.version);
+		ret = EINVAL;
+		goto err;
+	} else if (persist.version < DB_LOGOLDVER) {
+		status = DB_LV_OLD_UNREADABLE;
+		/*
+		 * We don't want to set persistent info based on an
+		 * unreadable region, so jump to "err".
+		 */
+		goto err;
+	} else if (persist.version < DB_LOGVERSION)
+		status = DB_LV_OLD_READABLE;
+
+	/*
+	 * If the log is thus far readable and we're doing system
+	 * initialization, set the region's persistent information
+	 * based on the headers.
+	 */
+	if (set_persist) {
+		region = dblp->reginfo.primary;
+		region->persist.lg_max = persist.lg_max;
+		region->persist.mode = persist.mode;
+	}
+
+err:	__os_freestr(fname);
+	*statusp = status;
+	return (ret);
+}
+
+/*
+ * __log_close --
+ *	Internal version of log_close: only called from dbenv_refresh.
+ *
+ * PUBLIC: int __log_close __P((DB_ENV *));
+ */
+int
+__log_close(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_LOG *dblp;
+	int ret, t_ret;
+
+	ret = 0;
+	dblp = dbenv->lg_handle;
+
+	/* We may have opened files as part of XA; if so, close them. */
+	F_SET(dblp, DBLOG_RECOVER);
+	__log_close_files(dbenv);
+
+	/* Discard the per-thread lock. */
+	if (dblp->mutexp != NULL)
+		__db_mutex_free(dbenv, &dblp->reginfo, dblp->mutexp);
+
+	/* Detach from the region. */
+	ret = __db_r_detach(dbenv, &dblp->reginfo, 0);
+
+	/* Close open files, release allocated memory. */
+	if (F_ISSET(&dblp->lfh, DB_FH_VALID) &&
+	    (t_ret = __os_closehandle(&dblp->lfh)) != 0 && ret == 0)
+		ret = t_ret;
+	if (dblp->c_dbt.data != NULL)
+		__os_free(dblp->c_dbt.data, dblp->c_dbt.ulen);
+	if (F_ISSET(&dblp->c_fh, DB_FH_VALID) &&
+	    (t_ret = __os_closehandle(&dblp->c_fh)) != 0 && ret == 0)
+		ret = t_ret;
+	if (dblp->dbentry != NULL)
+		__os_free(dblp->dbentry,
+		    (dblp->dbentry_cnt * sizeof(DB_ENTRY)));
+	if (dblp->readbufp != NULL)
+		__os_free(dblp->readbufp, dbenv->lg_bsize);
+
+	__os_free(dblp, sizeof(*dblp));
+
+	dbenv->lg_handle = NULL;
+	return (ret);
+}
+
+/*
+ * log_stat --
+ *	Return LOG statistics.
+ */
+int
+log_stat(dbenv, statp, db_malloc)
+	DB_ENV *dbenv;
+	DB_LOG_STAT **statp;
+	void *(*db_malloc) __P((size_t));
+{
+	DB_LOG *dblp;
+	DB_LOG_STAT *stats;
+	LOG *region;
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_stat(dbenv, statp, db_malloc));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	*statp = NULL;
+
+	dblp = dbenv->lg_handle;
+	region = dblp->reginfo.primary;
+
+	if ((ret = __os_malloc(dbenv,
+	    sizeof(DB_LOG_STAT), db_malloc, &stats)) != 0)
+		return (ret);
+
+	/* Copy out the global statistics. */
+	R_LOCK(dbenv, &dblp->reginfo);
+	*stats = region->stat;
+
+	stats->st_magic = region->persist.magic;
+	stats->st_version = region->persist.version;
+	stats->st_mode = region->persist.mode;
+	stats->st_lg_bsize = region->buffer_size;
+	stats->st_lg_max = region->persist.lg_max;
+
+	stats->st_region_wait = dblp->reginfo.rp->mutex.mutex_set_wait;
+	stats->st_region_nowait = dblp->reginfo.rp->mutex.mutex_set_nowait;
+	stats->st_regsize = dblp->reginfo.rp->size;
+
+	stats->st_cur_file = region->lsn.file;
+	stats->st_cur_offset = region->lsn.offset;
+
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	*statp = stats;
+	return (0);
+}
+
+/*
+ * __log_lastckp --
+ *	Return the current chkpt_lsn, so that we can store it in
+ *	the transaction region and keep the chain of checkpoints
+ *	unbroken across environment recreates.
+ *
+ * PUBLIC: int __log_lastckp __P((DB_ENV *, DB_LSN *));
+ */
+int
+__log_lastckp(dbenv, lsnp)
+	DB_ENV *dbenv;
+	DB_LSN *lsnp;
+{
+	LOG *lp;
+
+	lp = (LOG *)(((DB_LOG *)dbenv->lg_handle)->reginfo.primary);
+
+	*lsnp = lp->chkpt_lsn;
+	return (0);
+}
diff --git a/bdb/log/log.src b/bdb/log/log.src
new file mode 100644
index 00000000000..a92fae8de26
--- /dev/null
+++ b/bdb/log/log.src
@@ -0,0 +1,46 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ *
+ *	$Id: log.src,v 10.12 2000/02/17 20:24:10 bostic Exp $
+ */
+
+PREFIX	log
+
+INCLUDE	#include "db_config.h"
+INCLUDE
+INCLUDE #ifndef NO_SYSTEM_INCLUDES
+INCLUDE #include <sys/types.h>
+INCLUDE
+INCLUDE #include <ctype.h>
+INCLUDE #include <errno.h>
+INCLUDE #include <string.h>
+INCLUDE #endif
+INCLUDE
+INCLUDE #include "db_int.h"
+INCLUDE #include "db_page.h"
+INCLUDE #include "db_dispatch.h"
+INCLUDE #include "db_am.h"
+INCLUDE #include "log.h"
+INCLUDE #include "txn.h"
+INCLUDE
+
+/* Used for registering name/id translations at open or close. */
+DEPRECATED register1	1
+ARG	opcode		u_int32_t	lu
+DBT	name		DBT		s
+DBT	uid		DBT		s
+ARG	fileid		int32_t		ld
+ARG	ftype		DBTYPE		lx
+END
+
+BEGIN register		2
+ARG	opcode		u_int32_t	lu
+DBT	name		DBT		s
+DBT	uid		DBT		s
+ARG	fileid		int32_t		ld
+ARG	ftype		DBTYPE		lx
+ARG	meta_pgno	db_pgno_t	lu
+END
diff --git a/bdb/log/log_archive.c b/bdb/log/log_archive.c
new file mode 100644
index 00000000000..83728c79e55
--- /dev/null
+++ b/bdb/log/log_archive.c
@@ -0,0 +1,447 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_archive.c,v 11.13 2000/11/30 00:58:40 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "db_dispatch.h"
+#include "log.h"
+#include "clib_ext.h"			/* XXX: needed for getcwd. */
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+static int __absname __P((DB_ENV *, char *, char *, char **));
+static int __build_data __P((DB_ENV *, char *, char ***, void *(*)(size_t)));
+static int __cmpfunc __P((const void *, const void *));
+static int __usermem __P((DB_ENV *, char ***, void *(*)(size_t)));
+
+/*
+ * log_archive --
+ *	Supporting function for db_archive(1).
+ */
+int
+log_archive(dbenv, listp, flags, db_malloc)
+	DB_ENV *dbenv;
+	char ***listp;
+	u_int32_t flags;
+	void *(*db_malloc) __P((size_t));
+{
+	DBT rec;
+	DB_LOG *dblp;
+	DB_LSN stable_lsn;
+	u_int32_t fnum;
+	int array_size, n, ret;
+	char **array, **arrayp, *name, *p, *pref, buf[MAXPATHLEN];
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_archive(dbenv, listp, flags, db_malloc));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	name = NULL;
+	dblp = dbenv->lg_handle;
+	COMPQUIET(fnum, 0);
+
+#define	OKFLAGS	(DB_ARCH_ABS | DB_ARCH_DATA | DB_ARCH_LOG)
+	if (flags != 0) {
+		if ((ret =
+		    __db_fchk(dbenv, "log_archive", flags, OKFLAGS)) != 0)
+			return (ret);
+		if ((ret =
+		    __db_fcchk(dbenv,
+			"log_archive", flags, DB_ARCH_DATA, DB_ARCH_LOG)) != 0)
+			return (ret);
+	}
+
+	/*
+	 * Get the absolute pathname of the current directory.  It would
+	 * be nice to get the shortest pathname of the database directory,
+	 * but that's just not possible.
+	 *
+	 * XXX
+	 * Can't trust getcwd(3) to set a valid errno.  If it doesn't, just
+	 * guess that we ran out of memory.
+	 */
+	if (LF_ISSET(DB_ARCH_ABS)) {
+		__os_set_errno(0);
+		if ((pref = getcwd(buf, sizeof(buf))) == NULL) {
+			if (__os_get_errno() == 0)
+				__os_set_errno(ENOMEM);
+			return (__os_get_errno());
+		}
+	} else
+		pref = NULL;
+
+	switch (LF_ISSET(~DB_ARCH_ABS)) {
+	case DB_ARCH_DATA:
+		return (__build_data(dbenv, pref, listp, db_malloc));
+	case DB_ARCH_LOG:
+		memset(&rec, 0, sizeof(rec));
+		if (F_ISSET(dbenv, DB_ENV_THREAD))
+			F_SET(&rec, DB_DBT_MALLOC);
+		if ((ret = log_get(dbenv, &stable_lsn, &rec, DB_LAST)) != 0)
+			return (ret);
+		if (F_ISSET(dbenv, DB_ENV_THREAD))
+			__os_free(rec.data, rec.size);
+		fnum = stable_lsn.file;
+		break;
+	case 0:
+		if ((ret = __log_findckp(dbenv, &stable_lsn)) != 0) {
+			/*
+			 * A return of DB_NOTFOUND means that we didn't find
+			 * any records in the log (so we are not going to be
+			 * deleting any log files).
+			 */
+			if (ret != DB_NOTFOUND)
+				return (ret);
+			*listp = NULL;
+			return (0);
+		}
+		/* Remove any log files before the last stable LSN. */
+		fnum = stable_lsn.file - 1;
+		break;
+	}
+
+#define	LIST_INCREMENT	64
+	/* Get some initial space. */
+	array_size = 10;
+	if ((ret = __os_malloc(dbenv,
+	    sizeof(char *) * array_size, NULL, &array)) != 0)
+		return (ret);
+	array[0] = NULL;
+
+	/* Build an array of the file names. */
+	for (n = 0; fnum > 0; --fnum) {
+		if ((ret = __log_name(dblp, fnum, &name, NULL, 0)) != 0)
+			goto err;
+		if (__os_exists(name, NULL) != 0) {
+			if (LF_ISSET(DB_ARCH_LOG) && fnum == stable_lsn.file)
+				continue;
+			__os_freestr(name);
+			name = NULL;
+			break;
+		}
+
+		if (n >= array_size - 1) {
+			array_size += LIST_INCREMENT;
+			if ((ret = __os_realloc(dbenv,
+			    sizeof(char *) * array_size, NULL, &array)) != 0)
+				goto err;
+		}
+
+		if (LF_ISSET(DB_ARCH_ABS)) {
+			if ((ret = __absname(dbenv,
+			    pref, name, &array[n])) != 0)
+				goto err;
+			__os_freestr(name);
+		} else if ((p = __db_rpath(name)) != NULL) {
+			if ((ret = __os_strdup(dbenv, p + 1, &array[n])) != 0)
+				goto err;
+			__os_freestr(name);
+		} else
+			array[n] = name;
+
+		name = NULL;
+		array[++n] = NULL;
+	}
+
+	/* If there's nothing to return, we're done. */
+	if (n == 0) {
+		*listp = NULL;
+		ret = 0;
+		goto err;
+	}
+
+	/* Sort the list. */
+	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
+
+	/* Rework the memory. */
+	if ((ret = __usermem(dbenv, &array, db_malloc)) != 0)
+		goto err;
+
+	*listp = array;
+	return (0);
+
+err:	if (array != NULL) {
+		for (arrayp = array; *arrayp != NULL; ++arrayp)
+			__os_freestr(*arrayp);
+		__os_free(array, sizeof(char *) * array_size);
+	}
+	if (name != NULL)
+		__os_freestr(name);
+	return (ret);
+}
+
+/*
+ * __build_data --
+ *	Build a list of datafiles for return.
+ */
+static int
+__build_data(dbenv, pref, listp, db_malloc)
+	DB_ENV *dbenv;
+	char *pref, ***listp;
+	void *(*db_malloc) __P((size_t));
+{
+	DBT rec;
+	DB_LSN lsn;
+	__log_register_args *argp;
+	u_int32_t rectype;
+	int array_size, last, n, nxt, ret;
+	char **array, **arrayp, *p, *real_name;
+
+	/* Get some initial space. */
+	array_size = 10;
+	if ((ret = __os_malloc(dbenv,
+	    sizeof(char *) * array_size, NULL, &array)) != 0)
+		return (ret);
+	array[0] = NULL;
+
+	memset(&rec, 0, sizeof(rec));
+	if (F_ISSET(dbenv, DB_ENV_THREAD))
+		F_SET(&rec, DB_DBT_MALLOC);
+	for (n = 0, ret = log_get(dbenv, &lsn, &rec, DB_FIRST);
+	    ret == 0; ret = log_get(dbenv, &lsn, &rec, DB_NEXT)) {
+		if (rec.size < sizeof(rectype)) {
+			ret = EINVAL;
+			__db_err(dbenv, "log_archive: bad log record");
+			goto lg_free;
+		}
+
+		memcpy(&rectype, rec.data, sizeof(rectype));
+		if (rectype != DB_log_register) {
+			if (F_ISSET(dbenv, DB_ENV_THREAD)) {
+				__os_free(rec.data, rec.size);
+				rec.data = NULL;
+			}
+			continue;
+		}
+		if ((ret = __log_register_read(dbenv, rec.data, &argp)) != 0) {
+			ret = EINVAL;
+			__db_err(dbenv,
+			    "log_archive: unable to read log record");
+			goto lg_free;
+		}
+
+		if (n >= array_size - 1) {
+			array_size += LIST_INCREMENT;
+			if ((ret = __os_realloc(dbenv,
+			    sizeof(char *) * array_size, NULL, &array)) != 0)
+				goto lg_free;
+		}
+
+		if ((ret = __os_strdup(dbenv,
+		    argp->name.data, &array[n])) != 0) {
+lg_free:		if (F_ISSET(&rec, DB_DBT_MALLOC) && rec.data != NULL)
+				__os_free(rec.data, rec.size);
+			goto err1;
+		}
+
+		array[++n] = NULL;
+		__os_free(argp, 0);
+
+		if (F_ISSET(dbenv, DB_ENV_THREAD)) {
+			__os_free(rec.data, rec.size);
+			rec.data = NULL;
+		}
+	}
+
+	/* If there's nothing to return, we're done. */
+	if (n == 0) {
+		ret = 0;
+		*listp = NULL;
+		goto err1;
+	}
+
+	/* Sort the list. */
+	qsort(array, (size_t)n, sizeof(char *), __cmpfunc);
+
+	/*
+	 * Build the real pathnames, discarding nonexistent files and
+	 * duplicates.
+	 */
+	for (last = nxt = 0; nxt < n;) {
+		/*
+		 * Discard duplicates.  Last is the next slot we're going
+		 * to return to the user, nxt is the next slot that we're
+		 * going to consider.
+		 */
+		if (last != nxt) {
+			array[last] = array[nxt];
+			array[nxt] = NULL;
+		}
+		for (++nxt; nxt < n &&
+		    strcmp(array[last], array[nxt]) == 0; ++nxt) {
+			__os_freestr(array[nxt]);
+			array[nxt] = NULL;
+		}
+
+		/* Get the real name. */
+		if ((ret = __db_appname(dbenv,
+		    DB_APP_DATA, NULL, array[last], 0, NULL, &real_name)) != 0)
+			goto err2;
+
+		/* If the file doesn't exist, ignore it. */
+		if (__os_exists(real_name, NULL) != 0) {
+			__os_freestr(real_name);
+			__os_freestr(array[last]);
+			array[last] = NULL;
+			continue;
+		}
+
+		/* Rework the name as requested by the user. */
+		__os_freestr(array[last]);
+		array[last] = NULL;
+		if (pref != NULL) {
+			ret = __absname(dbenv, pref, real_name, &array[last]);
+			__os_freestr(real_name);
+			if (ret != 0)
+				goto err2;
+		} else if ((p = __db_rpath(real_name)) != NULL) {
+			ret = __os_strdup(dbenv, p + 1, &array[last]);
+			__os_freestr(real_name);
+			if (ret != 0)
+				goto err2;
+		} else
+			array[last] = real_name;
+		++last;
+	}
+
+	/* NULL-terminate the list. */
+	array[last] = NULL;
+
+	/* Rework the memory. */
+	if ((ret = __usermem(dbenv, &array, db_malloc)) != 0)
+		goto err1;
+
+	*listp = array;
+	return (0);
+
+err2:	/*
+	 * XXX
+	 * We've possibly inserted NULLs into the array list, so clean up a
+	 * bit so that the other error processing works.
+	 */
+	if (array != NULL)
+		for (; nxt < n; ++nxt)
+			__os_freestr(array[nxt]);
+	/* FALLTHROUGH */
+
+err1:	if (array != NULL) {
+		for (arrayp = array; *arrayp != NULL; ++arrayp)
+			__os_freestr(*arrayp);
+		__os_free(array, array_size * sizeof(char *));
+	}
+	return (ret);
+}
+
+/*
+ * __absname --
+ *	Return an absolute path name for the file.
+ */
+static int
+__absname(dbenv, pref, name, newnamep)
+	DB_ENV *dbenv;
+	char *pref, *name, **newnamep;
+{
+	size_t l_pref, l_name;
+	int isabspath, ret;
+	char *newname;
+
+	l_name = strlen(name);
+	isabspath = __os_abspath(name);
+	l_pref = isabspath ? 0 : strlen(pref);
+
+	/* Malloc space for concatenating the two. */
+	if ((ret = __os_malloc(dbenv,
+	    l_pref + l_name + 2, NULL, &newname)) != 0)
+		return (ret);
+	*newnamep = newname;
+
+	/* Build the name.  If `name' is an absolute path, ignore any prefix. */
+	if (!isabspath) {
+		memcpy(newname, pref, l_pref);
+		if (strchr(PATH_SEPARATOR, newname[l_pref - 1]) == NULL)
+			newname[l_pref++] = PATH_SEPARATOR[0];
+	}
+	memcpy(newname + l_pref, name, l_name + 1);
+
+	return (0);
+}
+
+/*
+ * __usermem --
+ *	Create a single chunk of memory that holds the returned information.
+ *	If the user has their own malloc routine, use it.
+ */
+static int
+__usermem(dbenv, listp, db_malloc)
+	DB_ENV *dbenv;
+	char ***listp;
+	void *(*db_malloc) __P((size_t));
+{
+	size_t len;
+	int ret;
+	char **array, **arrayp, **orig, *strp;
+
+	/* Find out how much space we need. */
+	for (len = 0, orig = *listp; *orig != NULL; ++orig)
+		len += sizeof(char *) + strlen(*orig) + 1;
+	len += sizeof(char *);
+
+	/* Allocate it and set up the pointers. */
+	if ((ret = __os_malloc(dbenv, len, db_malloc, &array)) != 0)
+		return (ret);
+
+	strp = (char *)(array + (orig - *listp) + 1);
+
+	/* Copy the original information into the new memory. */
+	for (orig = *listp, arrayp = array; *orig != NULL; ++orig, ++arrayp) {
+		len = strlen(*orig);
+		memcpy(strp, *orig, len + 1);
+		*arrayp = strp;
+		strp += len + 1;
+
+		__os_freestr(*orig);
+	}
+
+	/* NULL-terminate the list. */
+	*arrayp = NULL;
+
+	__os_free(*listp, 0);
+	*listp = array;
+
+	return (0);
+}
+
+static int
+__cmpfunc(p1, p2)
+	const void *p1, *p2;
+{
+	return (strcmp(*((char * const *)p1), *((char * const *)p2)));
+}
diff --git a/bdb/log/log_auto.c b/bdb/log/log_auto.c
new file mode 100644
index 00000000000..281296cc238
--- /dev/null
+++ b/bdb/log/log_auto.c
@@ -0,0 +1,326 @@
+/* Do not edit: automatically built by gen_rec.awk. */
+#include "db_config.h"
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "db_dispatch.h"
+#include "db_am.h"
+#include "log.h"
+#include "txn.h"
+
+int
+__log_register1_print(dbenv, dbtp, lsnp, notused2, notused3)
+	DB_ENV *dbenv;
+	DBT *dbtp;
+	DB_LSN *lsnp;
+	db_recops notused2;
+	void *notused3;
+{
+	__log_register1_args *argp;
+	u_int32_t i;
+	u_int ch;
+	int ret;
+
+	i = 0;
+	ch = 0;
+	notused2 = DB_TXN_ABORT;
+	notused3 = NULL;
+
+	if ((ret = __log_register1_read(dbenv, dbtp->data, &argp)) != 0)
+		return (ret);
+	printf("[%lu][%lu]log_register1: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
+	    (u_long)lsnp->file,
+	    (u_long)lsnp->offset,
+	    (u_long)argp->type,
+	    (u_long)argp->txnid->txnid,
+	    (u_long)argp->prev_lsn.file,
+	    (u_long)argp->prev_lsn.offset);
+	printf("\topcode: %lu\n", (u_long)argp->opcode);
+	printf("\tname: ");
+	for (i = 0; i < argp->name.size; i++) {
+		ch = ((u_int8_t *)argp->name.data)[i];
+		if (isprint(ch) || ch == 0xa)
+			putchar(ch);
+		else
+			printf("%#x ", ch);
+	}
+	printf("\n");
+	printf("\tuid: ");
+	for (i = 0; i < argp->uid.size; i++) {
+		ch = ((u_int8_t *)argp->uid.data)[i];
+		if (isprint(ch) || ch == 0xa)
+			putchar(ch);
+		else
+			printf("%#x ", ch);
+	}
+	printf("\n");
+	printf("\tfileid: %ld\n", (long)argp->fileid);
+	printf("\tftype: 0x%lx\n", (u_long)argp->ftype);
+	printf("\n");
+	__os_free(argp, 0);
+	return (0);
+}
+
+int
+__log_register1_read(dbenv, recbuf, argpp)
+	DB_ENV *dbenv;
+	void *recbuf;
+	__log_register1_args **argpp;
+{
+	__log_register1_args *argp;
+	u_int8_t *bp;
+	int ret;
+
+	ret = __os_malloc(dbenv, sizeof(__log_register1_args) +
+	    sizeof(DB_TXN), NULL, &argp);
+	if (ret != 0)
+		return (ret);
+	argp->txnid = (DB_TXN *)&argp[1];
+	bp = recbuf;
+	memcpy(&argp->type, bp, sizeof(argp->type));
+	bp += sizeof(argp->type);
+	memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
+	bp += sizeof(argp->txnid->txnid);
+	memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
+	bp += sizeof(DB_LSN);
+	memcpy(&argp->opcode, bp, sizeof(argp->opcode));
+	bp += sizeof(argp->opcode);
+	memset(&argp->name, 0, sizeof(argp->name));
+	memcpy(&argp->name.size, bp, sizeof(u_int32_t));
+	bp += sizeof(u_int32_t);
+	argp->name.data = bp;
+	bp += argp->name.size;
+	memset(&argp->uid, 0, sizeof(argp->uid));
+	memcpy(&argp->uid.size, bp, sizeof(u_int32_t));
+	bp += sizeof(u_int32_t);
+	argp->uid.data = bp;
+	bp += argp->uid.size;
+	memcpy(&argp->fileid, bp, sizeof(argp->fileid));
+	bp += sizeof(argp->fileid);
+	memcpy(&argp->ftype, bp, sizeof(argp->ftype));
+	bp += sizeof(argp->ftype);
+	*argpp = argp;
+	return (0);
+}
+
+int
+__log_register_log(dbenv, txnid, ret_lsnp, flags,
+	opcode, name, uid, fileid, ftype, meta_pgno)
+	DB_ENV *dbenv;
+	DB_TXN *txnid;
+	DB_LSN *ret_lsnp;
+	u_int32_t flags;
+	u_int32_t opcode;
+	const DBT *name;
+	const DBT *uid;
+	int32_t fileid;
+	DBTYPE ftype;
+	db_pgno_t meta_pgno;
+{
+	DBT logrec;
+	DB_LSN *lsnp, null_lsn;
+	u_int32_t zero;
+	u_int32_t rectype, txn_num;
+	int ret;
+	u_int8_t *bp;
+
+	rectype = DB_log_register;
+	if (txnid != NULL &&
+	    TAILQ_FIRST(&txnid->kids) != NULL &&
+	    (ret = __txn_activekids(dbenv, rectype, txnid)) != 0)
+		return (ret);
+	txn_num = txnid == NULL ? 0 : txnid->txnid;
+	if (txnid == NULL) {
+		ZERO_LSN(null_lsn);
+		lsnp = &null_lsn;
+	} else
+		lsnp = &txnid->last_lsn;
+	logrec.size = sizeof(rectype) + sizeof(txn_num) + sizeof(DB_LSN)
+	    + sizeof(opcode)
+	    + sizeof(u_int32_t) + (name == NULL ? 0 : name->size)
+	    + sizeof(u_int32_t) + (uid == NULL ? 0 : uid->size)
+	    + sizeof(fileid)
+	    + sizeof(ftype)
+	    + sizeof(meta_pgno);
+	if ((ret = __os_malloc(dbenv, logrec.size, NULL, &logrec.data)) != 0)
+		return (ret);
+
+	bp = logrec.data;
+	memcpy(bp, &rectype, sizeof(rectype));
+	bp += sizeof(rectype);
+	memcpy(bp, &txn_num, sizeof(txn_num));
+	bp += sizeof(txn_num);
+	memcpy(bp, lsnp, sizeof(DB_LSN));
+	bp += sizeof(DB_LSN);
+	memcpy(bp, &opcode, sizeof(opcode));
+	bp += sizeof(opcode);
+	if (name == NULL) {
+		zero = 0;
+		memcpy(bp, &zero, sizeof(u_int32_t));
+		bp += sizeof(u_int32_t);
+	} else {
+		memcpy(bp, &name->size, sizeof(name->size));
+		bp += sizeof(name->size);
+		memcpy(bp, name->data, name->size);
+		bp += name->size;
+	}
+	if (uid == NULL) {
+		zero = 0;
+		memcpy(bp, &zero, sizeof(u_int32_t));
+		bp += sizeof(u_int32_t);
+	} else {
+		memcpy(bp, &uid->size, sizeof(uid->size));
+		bp += sizeof(uid->size);
+		memcpy(bp, uid->data, uid->size);
+		bp += uid->size;
+	}
+	memcpy(bp, &fileid, sizeof(fileid));
+	bp += sizeof(fileid);
+	memcpy(bp, &ftype, sizeof(ftype));
+	bp += sizeof(ftype);
+	memcpy(bp, &meta_pgno, sizeof(meta_pgno));
+	bp += sizeof(meta_pgno);
+	DB_ASSERT((u_int32_t)(bp - (u_int8_t *)logrec.data) == logrec.size);
+	ret = __log_put(dbenv, ret_lsnp, (DBT *)&logrec, flags);
+	if (txnid != NULL)
+		txnid->last_lsn = *ret_lsnp;
+	__os_free(logrec.data, logrec.size);
+	return (ret);
+}
+
+int
+__log_register_print(dbenv, dbtp, lsnp, notused2, notused3)
+	DB_ENV *dbenv;
+	DBT *dbtp;
+	DB_LSN *lsnp;
+	db_recops notused2;
+	void *notused3;
+{
+	__log_register_args *argp;
+	u_int32_t i;
+	u_int ch;
+	int ret;
+
+	i = 0;
+	ch = 0;
+	notused2 = DB_TXN_ABORT;
+	notused3 = NULL;
+
+	if ((ret = __log_register_read(dbenv, dbtp->data, &argp)) != 0)
+		return (ret);
+	printf("[%lu][%lu]log_register: rec: %lu txnid %lx prevlsn [%lu][%lu]\n",
+	    (u_long)lsnp->file,
+	    (u_long)lsnp->offset,
+	    (u_long)argp->type,
+	    (u_long)argp->txnid->txnid,
+	    (u_long)argp->prev_lsn.file,
+	    (u_long)argp->prev_lsn.offset);
+	printf("\topcode: %lu\n", (u_long)argp->opcode);
+	printf("\tname: ");
+	for (i = 0; i < argp->name.size; i++) {
+		ch = ((u_int8_t *)argp->name.data)[i];
+		if (isprint(ch) || ch == 0xa)
+			putchar(ch);
+		else
+			printf("%#x ", ch);
+	}
+	printf("\n");
+	printf("\tuid: ");
+	for (i = 0; i < argp->uid.size; i++) {
+		ch = ((u_int8_t *)argp->uid.data)[i];
+		if (isprint(ch) || ch == 0xa)
+			putchar(ch);
+		else
+			printf("%#x ", ch);
+	}
+	printf("\n");
+	printf("\tfileid: %ld\n", (long)argp->fileid);
+	printf("\tftype: 0x%lx\n", (u_long)argp->ftype);
+	printf("\tmeta_pgno: %lu\n", (u_long)argp->meta_pgno);
+	printf("\n");
+	__os_free(argp, 0);
+	return (0);
+}
+
+int
+__log_register_read(dbenv, recbuf, argpp)
+	DB_ENV *dbenv;
+	void *recbuf;
+	__log_register_args **argpp;
+{
+	__log_register_args *argp;
+	u_int8_t *bp;
+	int ret;
+
+	ret = __os_malloc(dbenv, sizeof(__log_register_args) +
+	    sizeof(DB_TXN), NULL, &argp);
+	if (ret != 0)
+		return (ret);
+	argp->txnid = (DB_TXN *)&argp[1];
+	bp = recbuf;
+	memcpy(&argp->type, bp, sizeof(argp->type));
+	bp += sizeof(argp->type);
+	memcpy(&argp->txnid->txnid,  bp, sizeof(argp->txnid->txnid));
+	bp += sizeof(argp->txnid->txnid);
+	memcpy(&argp->prev_lsn, bp, sizeof(DB_LSN));
+	bp += sizeof(DB_LSN);
+	memcpy(&argp->opcode, bp, sizeof(argp->opcode));
+	bp += sizeof(argp->opcode);
+	memset(&argp->name, 0, sizeof(argp->name));
+	memcpy(&argp->name.size, bp, sizeof(u_int32_t));
+	bp += sizeof(u_int32_t);
+	argp->name.data = bp;
+	bp += argp->name.size;
+	memset(&argp->uid, 0, sizeof(argp->uid));
+	memcpy(&argp->uid.size, bp, sizeof(u_int32_t));
+	bp += sizeof(u_int32_t);
+	argp->uid.data = bp;
+	bp += argp->uid.size;
+	memcpy(&argp->fileid, bp, sizeof(argp->fileid));
+	bp += sizeof(argp->fileid);
+	memcpy(&argp->ftype, bp, sizeof(argp->ftype));
+	bp += sizeof(argp->ftype);
+	memcpy(&argp->meta_pgno, bp, sizeof(argp->meta_pgno));
+	bp += sizeof(argp->meta_pgno);
+	*argpp = argp;
+	return (0);
+}
+
+int
+__log_init_print(dbenv)
+	DB_ENV *dbenv;
+{
+	int ret;
+
+	if ((ret = __db_add_recovery(dbenv,
+	    __log_register1_print, DB_log_register1)) != 0)
+		return (ret);
+	if ((ret = __db_add_recovery(dbenv,
+	    __log_register_print, DB_log_register)) != 0)
+		return (ret);
+	return (0);
+}
+
+int
+__log_init_recover(dbenv)
+	DB_ENV *dbenv;
+{
+	int ret;
+
+	if ((ret = __db_add_recovery(dbenv,
+	    __deprecated_recover, DB_log_register1)) != 0)
+		return (ret);
+	if ((ret = __db_add_recovery(dbenv,
+	    __log_register_recover, DB_log_register)) != 0)
+		return (ret);
+	return (0);
+}
+
diff --git a/bdb/log/log_compare.c b/bdb/log/log_compare.c
new file mode 100644
index 00000000000..9bc3c028a5f
--- /dev/null
+++ b/bdb/log/log_compare.c
@@ -0,0 +1,34 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_compare.c,v 11.3 2000/02/14 02:59:59 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+#endif
+
+#include "db_int.h"
+
+/*
+ * log_compare --
+ *	Compare two LSN's; return 1, 0, -1 if first is >, == or < second.
+ */
+int
+log_compare(lsn0, lsn1)
+	const DB_LSN *lsn0, *lsn1;
+{
+	if (lsn0->file != lsn1->file)
+		return (lsn0->file < lsn1->file ? -1 : 1);
+
+	if (lsn0->offset != lsn1->offset)
+		return (lsn0->offset < lsn1->offset ? -1 : 1);
+
+	return (0);
+}
diff --git a/bdb/log/log_findckp.c b/bdb/log/log_findckp.c
new file mode 100644
index 00000000000..b1e8fddbdb7
--- /dev/null
+++ b/bdb/log/log_findckp.c
@@ -0,0 +1,135 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_findckp.c,v 11.5 2000/11/30 00:58:40 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "log.h"
+#include "txn.h"
+
+/*
+ * __log_findckp --
+ *
+ * Looks for the most recent checkpoint that occurs before the most recent
+ * checkpoint LSN, subject to the constraint that there must be at least two
+ * checkpoints.  The reason you need two checkpoints is that you might have
+ * crashed during the most recent one and may not have a copy of all the
+ * open files.  This is the point from which recovery can start and the
+ * point up to which archival/truncation can take place.  Checkpoints in
+ * the log look like:
+ *
+ * -------------------------------------------------------------------
+ *  | ckp A, ckplsn 100 |  .... record .... | ckp B, ckplsn 600 | ...
+ * -------------------------------------------------------------------
+ *         LSN 500                                 LSN 1000
+ *
+ * If we read what log returns from using the DB_CKP parameter to logput,
+ * we'll get the record at LSN 1000.  The checkpoint LSN there is 600.
+ * Now we have to scan backwards looking for a checkpoint before LSN 600.
+ * We find one at 500.  This means that we can truncate the log before
+ * 500 or run recovery beginning at 500.
+ *
+ * Returns 0 if we find a suitable checkpoint or we retrieved the first
+ * record in the log from which to start.  Returns DB_NOTFOUND if there
+ * are no log records, errno on error.
+ *
+ * PUBLIC: int __log_findckp __P((DB_ENV *, DB_LSN *));
+ */
+int
+__log_findckp(dbenv, lsnp)
+	DB_ENV *dbenv;
+	DB_LSN *lsnp;
+{
+	DBT data;
+	DB_LSN ckp_lsn, final_ckp, last_ckp, next_lsn;
+	__txn_ckp_args *ckp_args;
+	int ret;
+
+	/*
+	 * Need to find the appropriate point from which to begin
+	 * recovery.
+	 */
+	memset(&data, 0, sizeof(data));
+	if (F_ISSET(dbenv, DB_ENV_THREAD))
+		F_SET(&data, DB_DBT_MALLOC);
+	ZERO_LSN(ckp_lsn);
+	if ((ret = log_get(dbenv, &last_ckp, &data, DB_CHECKPOINT)) != 0) {
+		if (ret == ENOENT)
+			goto get_first;
+		else
+			return (ret);
+	}
+	final_ckp = last_ckp;
+
+	next_lsn = last_ckp;
+	do {
+		if (F_ISSET(dbenv, DB_ENV_THREAD))
+			__os_free(data.data, data.size);
+
+		if ((ret = log_get(dbenv, &next_lsn, &data, DB_SET)) != 0)
+			return (ret);
+		if ((ret = __txn_ckp_read(dbenv, data.data, &ckp_args)) != 0) {
+			if (F_ISSET(dbenv, DB_ENV_THREAD))
+				__os_free(data.data, data.size);
+			return (ret);
+		}
+		if (IS_ZERO_LSN(ckp_lsn))
+			ckp_lsn = ckp_args->ckp_lsn;
+		if (FLD_ISSET(dbenv->verbose, DB_VERB_CHKPOINT)) {
+			__db_err(dbenv, "Checkpoint at: [%lu][%lu]",
+			    (u_long)last_ckp.file, (u_long)last_ckp.offset);
+			__db_err(dbenv, "Checkpoint LSN: [%lu][%lu]",
+			    (u_long)ckp_args->ckp_lsn.file,
+			    (u_long)ckp_args->ckp_lsn.offset);
+			__db_err(dbenv, "Previous checkpoint: [%lu][%lu]",
+			    (u_long)ckp_args->last_ckp.file,
+			    (u_long)ckp_args->last_ckp.offset);
+		}
+		last_ckp = next_lsn;
+		next_lsn = ckp_args->last_ckp;
+		__os_free(ckp_args, sizeof(*ckp_args));
+
+		/*
+		 * Keep looping until either you 1) run out of checkpoints,
+		 * 2) you've found a checkpoint before the most recent
+		 * checkpoint's LSN and you have at least 2 checkpoints.
+		 */
+	} while (!IS_ZERO_LSN(next_lsn) &&
+	    (log_compare(&last_ckp, &ckp_lsn) > 0 ||
+	    log_compare(&final_ckp, &last_ckp) == 0));
+
+	if (F_ISSET(dbenv, DB_ENV_THREAD))
+		__os_free(data.data, data.size);
+
+	/*
+	 * At this point, either, next_lsn is ZERO or ckp_lsn is the
+	 * checkpoint lsn and last_ckp is the LSN of the last checkpoint
+	 * before ckp_lsn.  If the compare in the loop is still true, then
+	 * next_lsn must be 0 and we need to roll forward from the
+	 * beginning of the log.
+	 */
+	if (log_compare(&last_ckp, &ckp_lsn) >= 0 ||
+	    log_compare(&final_ckp, &last_ckp) == 0) {
+get_first:	if ((ret = log_get(dbenv, &last_ckp, &data, DB_FIRST)) != 0)
+			return (ret);
+		if (F_ISSET(dbenv, DB_ENV_THREAD))
+			__os_free(data.data, data.size);
+	}
+	*lsnp = last_ckp;
+
+	return (IS_ZERO_LSN(last_ckp) ? DB_NOTFOUND : 0);
+}
diff --git a/bdb/log/log_get.c b/bdb/log/log_get.c
new file mode 100644
index 00000000000..b75d50a62fd
--- /dev/null
+++ b/bdb/log/log_get.c
@@ -0,0 +1,465 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_get.c,v 11.32 2001/01/11 18:19:53 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "log.h"
+#include "hash.h"
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+/*
+ * log_get --
+ *	Get a log record.
+ */
+int
+log_get(dbenv, alsn, dbt, flags)
+	DB_ENV *dbenv;
+	DB_LSN *alsn;
+	DBT *dbt;
+	u_int32_t flags;
+{
+	DB_LOG *dblp;
+	DB_LSN saved_lsn;
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_get(dbenv, alsn, dbt, flags));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	/* Validate arguments. */
+	if (flags != DB_CHECKPOINT && flags != DB_CURRENT &&
+	    flags != DB_FIRST && flags != DB_LAST &&
+	    flags != DB_NEXT && flags != DB_PREV && flags != DB_SET)
+		return (__db_ferr(dbenv, "log_get", 1));
+
+	if (F_ISSET(dbenv, DB_ENV_THREAD)) {
+		if (flags == DB_NEXT || flags == DB_PREV || flags == DB_CURRENT)
+			return (__db_ferr(dbenv, "log_get", 1));
+		if (!F_ISSET(dbt,
+		    DB_DBT_MALLOC | DB_DBT_REALLOC | DB_DBT_USERMEM))
+			return (__db_ferr(dbenv, "threaded data", 1));
+	}
+
+	dblp = dbenv->lg_handle;
+	R_LOCK(dbenv, &dblp->reginfo);
+
+	/*
+	 * The alsn field is only initialized if DB_SET is the flag, so this
+	 * assignment causes uninitialized memory complaints for other flag
+	 * values.
+	 */
+#ifdef	UMRW
+	if (flags == DB_SET)
+		saved_lsn = *alsn;
+	else
+		ZERO_LSN(saved_lsn);
+#else
+	saved_lsn = *alsn;
+#endif
+
+	/*
+	 * If we get one of the log's header records, repeat the operation.
+	 * This assumes that applications don't ever request the log header
+	 * records by LSN, but that seems reasonable to me.
+	 */
+	if ((ret = __log_get(dblp,
+	    alsn, dbt, flags, 0)) == 0 && alsn->offset == 0) {
+		switch (flags) {
+		case DB_FIRST:
+			flags = DB_NEXT;
+			break;
+		case DB_LAST:
+			flags = DB_PREV;
+			break;
+		}
+		if (F_ISSET(dbt, DB_DBT_MALLOC)) {
+			__os_free(dbt->data, dbt->size);
+			dbt->data = NULL;
+		}
+		ret = __log_get(dblp, alsn, dbt, flags, 0);
+	}
+	if (ret != 0)
+		*alsn = saved_lsn;
+
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	return (ret);
+}
+
+/*
+ * __log_get --
+ *	Get a log record; internal version.
+ *
+ * PUBLIC: int __log_get __P((DB_LOG *, DB_LSN *, DBT *, u_int32_t, int));
+ */
+int
+__log_get(dblp, alsn, dbt, flags, silent)
+	DB_LOG *dblp;
+	DB_LSN *alsn;
+	DBT *dbt;
+	u_int32_t flags;
+	int silent;
+{
+	DB_ENV *dbenv;
+	DB_LSN nlsn;
+	HDR hdr;
+	LOG *lp;
+	const char *fail;
+	char *np, *tbuf;
+	int cnt, ret;
+	logfile_validity status;
+	size_t len, nr;
+	u_int32_t offset;
+	u_int8_t *p;
+	void *shortp, *readp;
+
+	lp = dblp->reginfo.primary;
+	fail = np = tbuf = NULL;
+	dbenv = dblp->dbenv;
+
+	nlsn = dblp->c_lsn;
+	switch (flags) {
+	case DB_CHECKPOINT:
+		nlsn = lp->chkpt_lsn;
+		if (IS_ZERO_LSN(nlsn)) {
+			/* No db_err. The caller may expect this. */
+			ret = ENOENT;
+			goto err2;
+		}
+		break;
+	case DB_NEXT:				/* Next log record. */
+		if (!IS_ZERO_LSN(nlsn)) {
+			/* Increment the cursor by the cursor record size. */
+			nlsn.offset += dblp->c_len;
+			break;
+		}
+		/* FALLTHROUGH */
+	case DB_FIRST:				/* Find the first log record. */
+		/* Find the first log file. */
+		if ((ret = __log_find(dblp, 1, &cnt, &status)) != 0)
+			goto err2;
+
+		/*
+		 * We want any readable version, so either DB_LV_NORMAL
+		 * or DB_LV_OLD_READABLE is acceptable here.  If it's
+		 * not one of those two, there is no first log record that
+		 * we can read.
+		 */
+		if (status != DB_LV_NORMAL && status != DB_LV_OLD_READABLE) {
+			ret = DB_NOTFOUND;
+			goto err2;
+		}
+
+		/*
+		 * We may have only entered records in the buffer, and not
+		 * yet written a log file.  If no log files were found and
+		 * there's anything in the buffer, it belongs to file 1.
+		 */
+		if (cnt == 0)
+			cnt = 1;
+
+		nlsn.file = cnt;
+		nlsn.offset = 0;
+		break;
+	case DB_CURRENT:			/* Current log record. */
+		break;
+	case DB_PREV:				/* Previous log record. */
+		if (!IS_ZERO_LSN(nlsn)) {
+			/* If at start-of-file, move to the previous file. */
+			if (nlsn.offset == 0) {
+				if (nlsn.file == 1 ||
+				    __log_valid(dblp,
+					nlsn.file - 1, 0, &status) != 0)
+					return (DB_NOTFOUND);
+
+				if (status != DB_LV_NORMAL &&
+				    status != DB_LV_OLD_READABLE)
+					return (DB_NOTFOUND);
+
+				--nlsn.file;
+				nlsn.offset = dblp->c_off;
+			} else
+				nlsn.offset = dblp->c_off;
+			break;
+		}
+		/* FALLTHROUGH */
+	case DB_LAST:				/* Last log record. */
+		nlsn.file = lp->lsn.file;
+		nlsn.offset = lp->lsn.offset - lp->len;
+		break;
+	case DB_SET:				/* Set log record. */
+		nlsn = *alsn;
+		break;
+	}
+
+	if (0) {				/* Move to the next file. */
+next_file:	++nlsn.file;
+		nlsn.offset = 0;
+	}
+
+	/* Return 1 if the request is past the end of the log. */
+	if (nlsn.file > lp->lsn.file ||
+	    (nlsn.file == lp->lsn.file && nlsn.offset >= lp->lsn.offset))
+		return (DB_NOTFOUND);
+
+	/* If we've switched files, discard the current file handle. */
+	if (dblp->c_lsn.file != nlsn.file &&
+	    F_ISSET(&dblp->c_fh, DB_FH_VALID)) {
+		(void)__os_closehandle(&dblp->c_fh);
+	}
+
+	/* If the entire record is in the in-memory buffer, copy it out. */
+	if (nlsn.file == lp->lsn.file && nlsn.offset >= lp->w_off) {
+		/* Copy the header. */
+		p = dblp->bufp + (nlsn.offset - lp->w_off);
+		memcpy(&hdr, p, sizeof(HDR));
+
+		/* Copy the record. */
+		len = hdr.len - sizeof(HDR);
+		if ((ret = __db_retcopy(NULL, dbt, p + sizeof(HDR),
+		    len, &dblp->c_dbt.data, &dblp->c_dbt.ulen)) != 0)
+			goto err2;
+		goto cksum;
+	}
+
+	shortp = NULL;
+
+	/* Acquire a file descriptor. */
+	if (!F_ISSET(&dblp->c_fh, DB_FH_VALID)) {
+		if ((ret = __log_name(dblp, nlsn.file,
+		    &np, &dblp->c_fh, DB_OSO_RDONLY | DB_OSO_SEQ)) != 0) {
+			fail = np;
+			goto err1;
+		}
+		__os_freestr(np);
+		np = NULL;
+	}
+
+	/* See if we've already read this */
+	if (nlsn.file == dblp->r_file && nlsn.offset > dblp->r_off
+	     && nlsn.offset + sizeof(HDR) < dblp->r_off + dblp->r_size)
+		goto got_header;
+
+	/*
+	 * Seek to the header offset and read the header.  Because the file
+	 * may be pre-allocated, we have to make sure that we're not reading
+	 * past the information in the start of the in-memory buffer.
+	 */
+
+	readp = &hdr;
+	offset = nlsn.offset;
+	if (nlsn.file == lp->lsn.file && offset + sizeof(HDR) > lp->w_off)
+		nr = lp->w_off - offset;
+	else if (dblp->readbufp == NULL)
+		nr = sizeof(HDR);
+	else  {
+		nr = lp->buffer_size;
+		readp = dblp->readbufp;
+		dblp->r_file = nlsn.file;
+		/* Going backwards.  Put the current in the middle. */
+		if (flags == DB_PREV || flags == DB_LAST) {
+			if (offset <= lp->buffer_size/2)
+				offset = 0;
+			else
+				offset = offset - lp->buffer_size/2;
+		}
+		if (nlsn.file == lp->lsn.file && offset + nr > lp->lsn.offset)
+			nr = lp->lsn.offset - offset;
+		dblp->r_off = offset;
+	}
+
+	if ((ret = __os_seek(dblp->dbenv,
+	    &dblp->c_fh, 0, 0, offset, 0, DB_OS_SEEK_SET)) != 0) {
+		fail = "seek";
+		goto err1;
+	}
+	if ((ret = __os_read(dblp->dbenv, &dblp->c_fh, readp, nr, &nr)) != 0) {
+		fail = "read";
+		goto err1;
+	}
+	if (nr < sizeof(HDR)) {
+		/* If read returns EOF, try the next file. */
+		if (nr == 0) {
+			if (flags != DB_NEXT || nlsn.file == lp->lsn.file)
+				goto corrupt;
+			goto next_file;
+		}
+
+		if (dblp->readbufp != NULL)
+			memcpy((u_int8_t *) &hdr, readp, nr);
+
+		/*
+		 * If read returns a short count the rest of the record has
+		 * to be in the in-memory buffer.
+		 */
+		if (lp->b_off < sizeof(HDR) - nr)
+			goto corrupt;
+
+		/* Get the rest of the header from the in-memory buffer. */
+		memcpy((u_int8_t *)&hdr + nr, dblp->bufp, sizeof(HDR) - nr);
+
+		if (hdr.len == 0)
+			goto next_file;
+
+		shortp = dblp->bufp + (sizeof(HDR) - nr);
+	}
+
+	else if (dblp->readbufp != NULL) {
+		dblp->r_size = nr;
+got_header:	memcpy((u_int8_t *)&hdr,
+		    dblp->readbufp + (nlsn.offset - dblp->r_off), sizeof(HDR));
+	}
+
+	/*
+	 * Check for buffers of 0's, that's what we usually see during recovery,
+	 * although it's certainly not something on which we can depend.  Check
+	 * for impossibly large records.  The malloc should fail later, but we
+	 * have customers that run mallocs that handle allocation failure as a
+	 * fatal error.
+	 */
+	if (hdr.len == 0)
+		goto next_file;
+	if (hdr.len <= sizeof(HDR) || hdr.len > lp->persist.lg_max)
+		goto corrupt;
+	len = hdr.len - sizeof(HDR);
+
+	/* If we've already moved to the in-memory buffer, fill from there. */
+	if (shortp != NULL) {
+		if (lp->b_off < ((u_int8_t *)shortp - dblp->bufp) + len)
+			goto corrupt;
+		if ((ret = __db_retcopy(NULL, dbt, shortp, len,
+		    &dblp->c_dbt.data, &dblp->c_dbt.ulen)) != 0)
+			goto err2;
+		goto cksum;
+	}
+
+	if (dblp->readbufp != NULL) {
+		if (nlsn.offset + hdr.len < dblp->r_off + dblp->r_size) {
+			if ((ret = __db_retcopy(NULL, dbt, dblp->readbufp +
+			     (nlsn.offset - dblp->r_off) + sizeof(HDR),
+			     len, &dblp->c_dbt.data, &dblp->c_dbt.ulen)) != 0)
+				goto err2;
+			goto cksum;
+		} else if ((ret = __os_seek(dblp->dbenv, &dblp->c_fh, 0,
+		    0, nlsn.offset + sizeof(HDR), 0, DB_OS_SEEK_SET)) != 0) {
+			fail = "seek";
+			goto err1;
+		}
+	}
+
+	/*
+	 * Allocate temporary memory to hold the record.
+	 *
+	 * XXX
+	 * We're calling malloc(3) with a region locked.  This isn't
+	 * a good idea.
+	 */
+	if ((ret = __os_malloc(dbenv, len, NULL, &tbuf)) != 0)
+		goto err1;
+
+	/*
+	 * Read the record into the buffer.  If read returns a short count,
+	 * there was an error or the rest of the record is in the in-memory
+	 * buffer.  Note, the information may be garbage if we're in recovery,
+	 * so don't read past the end of the buffer's memory.
+	 *
+	 * Because the file may be pre-allocated, we have to make sure that
+	 * we're not reading past the information in the start of the in-memory
+	 * buffer.
+	 */
+	if (nlsn.file == lp->lsn.file &&
+	    nlsn.offset + sizeof(HDR) + len > lp->w_off)
+		nr = lp->w_off - (nlsn.offset + sizeof(HDR));
+	else
+		nr = len;
+	if ((ret = __os_read(dblp->dbenv, &dblp->c_fh, tbuf, nr, &nr)) != 0) {
+		fail = "read";
+		goto err1;
+	}
+	if (len - nr > lp->buffer_size)
+		goto corrupt;
+	if (nr != len) {
+		if (lp->b_off < len - nr)
+			goto corrupt;
+
+		/* Get the rest of the record from the in-memory buffer. */
+		memcpy((u_int8_t *)tbuf + nr, dblp->bufp, len - nr);
+	}
+
+	/* Copy the record into the user's DBT. */
+	if ((ret = __db_retcopy(NULL, dbt, tbuf, len,
+	    &dblp->c_dbt.data, &dblp->c_dbt.ulen)) != 0)
+		goto err2;
+	__os_free(tbuf, 0);
+	tbuf = NULL;
+
+cksum:	/*
+	 * If the user specified a partial record read, the checksum can't
+	 * match.  It's not an obvious thing to do, but a user testing for
+	 * the length of a record might do it.
+	 */
+	if (!F_ISSET(dbt, DB_DBT_PARTIAL) &&
+	    hdr.cksum != __ham_func4(NULL, dbt->data, dbt->size)) {
+		if (!silent)
+			__db_err(dbenv, "log_get: checksum mismatch");
+		goto corrupt;
+	}
+
+	/* Update the cursor and the return lsn. */
+	dblp->c_off = hdr.prev;
+	dblp->c_len = hdr.len;
+	dblp->c_lsn = nlsn;
+	*alsn = nlsn;
+
+	return (0);
+
+corrupt:/*
+	 * This is the catchall -- for some reason we didn't find enough
+	 * information or it wasn't reasonable information, and it wasn't
+	 * because a system call failed.
+	 */
+	ret = EIO;
+	fail = "read";
+
+err1:	if (!silent) {
+		if (fail == NULL)
+			__db_err(dbenv, "log_get: %s", db_strerror(ret));
+		else
+			__db_err(dbenv,
+			    "log_get: %s: %s", fail, db_strerror(ret));
+	}
+
+err2:	if (np != NULL)
+		__os_freestr(np);
+	if (tbuf != NULL)
+		__os_free(tbuf, 0);
+	return (ret);
+}
diff --git a/bdb/log/log_method.c b/bdb/log/log_method.c
new file mode 100644
index 00000000000..883f485d891
--- /dev/null
+++ b/bdb/log/log_method.c
@@ -0,0 +1,121 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_method.c,v 11.14 2000/11/30 00:58:40 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "log.h"
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+static int __log_set_lg_max __P((DB_ENV *, u_int32_t));
+static int __log_set_lg_bsize __P((DB_ENV *, u_int32_t));
+static int __log_set_lg_dir __P((DB_ENV *, const char *));
+
+/*
+ * __log_dbenv_create --
+ *	Log specific initialization of the DB_ENV structure.
+ *
+ * PUBLIC: void __log_dbenv_create __P((DB_ENV *));
+ */
+void
+__log_dbenv_create(dbenv)
+	DB_ENV *dbenv;
+{
+	dbenv->lg_bsize = LG_BSIZE_DEFAULT;
+	dbenv->set_lg_bsize = __log_set_lg_bsize;
+
+	dbenv->lg_max = LG_MAX_DEFAULT;
+	dbenv->set_lg_max = __log_set_lg_max;
+
+	dbenv->set_lg_dir = __log_set_lg_dir;
+#ifdef	HAVE_RPC
+	/*
+	 * If we have a client, overwrite what we just setup to
+	 * point to client functions.
+	 */
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT)) {
+		dbenv->set_lg_bsize = __dbcl_set_lg_bsize;
+		dbenv->set_lg_max = __dbcl_set_lg_max;
+		dbenv->set_lg_dir = __dbcl_set_lg_dir;
+	}
+#endif
+}
+
+/*
+ * __log_set_lg_bsize --
+ *	Set the log buffer size.
+ */
+static int
+__log_set_lg_bsize(dbenv, lg_bsize)
+	DB_ENV *dbenv;
+	u_int32_t lg_bsize;
+{
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_lg_bsize");
+
+					/* Let's not be silly. */
+	if (lg_bsize > dbenv->lg_max / 4) {
+		__db_err(dbenv, "log buffer size must be <= log file size / 4");
+		return (EINVAL);
+	}
+
+	dbenv->lg_bsize = lg_bsize;
+	return (0);
+}
+
+/*
+ * __log_set_lg_max --
+ *	Set the maximum log file size.
+ */
+static int
+__log_set_lg_max(dbenv, lg_max)
+	DB_ENV *dbenv;
+	u_int32_t lg_max;
+{
+	ENV_ILLEGAL_AFTER_OPEN(dbenv, "set_lg_max");
+
+					/* Let's not be silly. */
+	if (lg_max < dbenv->lg_bsize * 4) {
+		__db_err(dbenv, "log file size must be >= log buffer size * 4");
+		return (EINVAL);
+	}
+
+	dbenv->lg_max = lg_max;
+	return (0);
+}
+
+/*
+ * __log_set_lg_dir --
+ *	Set the log file directory.
+ */
+static int
+__log_set_lg_dir(dbenv, dir)
+	DB_ENV *dbenv;
+	const char *dir;
+{
+	if (dbenv->db_log_dir != NULL)
+		__os_freestr(dbenv->db_log_dir);
+	return (__os_strdup(dbenv, dir, &dbenv->db_log_dir));
+}
diff --git a/bdb/log/log_put.c b/bdb/log/log_put.c
new file mode 100644
index 00000000000..e5cdedb5493
--- /dev/null
+++ b/bdb/log/log_put.c
@@ -0,0 +1,701 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_put.c,v 11.26 2000/11/30 00:58:40 ubell Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#if TIME_WITH_SYS_TIME
+#include <sys/time.h>
+#include <time.h>
+#else
+#if HAVE_SYS_TIME_H
+#include <sys/time.h>
+#else
+#include <time.h>
+#endif
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "log.h"
+#include "hash.h"
+#include "clib_ext.h"
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+static int __log_fill __P((DB_LOG *, DB_LSN *, void *, u_int32_t));
+static int __log_flush __P((DB_LOG *, const DB_LSN *));
+static int __log_newfh __P((DB_LOG *));
+static int __log_putr __P((DB_LOG *, DB_LSN *, const DBT *, u_int32_t));
+static int __log_open_files __P((DB_ENV *));
+static int __log_write __P((DB_LOG *, void *, u_int32_t));
+
+/*
+ * log_put --
+ *	Write a log record.
+ */
+int
+log_put(dbenv, lsn, dbt, flags)
+	DB_ENV *dbenv;
+	DB_LSN *lsn;
+	const DBT *dbt;
+	u_int32_t flags;
+{
+	DB_LOG *dblp;
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_put(dbenv, lsn, dbt, flags));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	/* Validate arguments. */
+	if (flags != 0 && flags != DB_CHECKPOINT &&
+	    flags != DB_CURLSN && flags != DB_FLUSH)
+		return (__db_ferr(dbenv, "log_put", 0));
+
+	dblp = dbenv->lg_handle;
+	R_LOCK(dbenv, &dblp->reginfo);
+	ret = __log_put(dbenv, lsn, dbt, flags);
+	R_UNLOCK(dbenv, &dblp->reginfo);
+	return (ret);
+}
+
+/*
+ * __log_put --
+ *	Write a log record; internal version.
+ *
+ * PUBLIC: int __log_put __P((DB_ENV *, DB_LSN *, const DBT *, u_int32_t));
+ */
+int
+__log_put(dbenv, lsn, dbt, flags)
+	DB_ENV *dbenv;
+	DB_LSN *lsn;
+	const DBT *dbt;
+	u_int32_t flags;
+{
+	DBT t;
+	DB_LOG *dblp;
+	LOG *lp;
+	u_int32_t lastoff;
+	int ret;
+
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+
+	/*
+	 * If the application just wants to know where we are, fill in
+	 * the information.  Currently used by the transaction manager
+	 * to avoid writing TXN_begin records.
+	 */
+	if (flags == DB_CURLSN) {
+		lsn->file = lp->lsn.file;
+		lsn->offset = lp->lsn.offset;
+		return (0);
+	}
+
+	/* If this information won't fit in the file, swap files. */
+	if (lp->lsn.offset + sizeof(HDR) + dbt->size > lp->persist.lg_max) {
+		if (sizeof(HDR) +
+		    sizeof(LOGP) + dbt->size > lp->persist.lg_max) {
+			__db_err(dbenv,
+			    "log_put: record larger than maximum file size");
+			return (EINVAL);
+		}
+
+		/* Flush the log. */
+		if ((ret = __log_flush(dblp, NULL)) != 0)
+			return (ret);
+
+		/*
+		 * Save the last known offset from the previous file, we'll
+		 * need it to initialize the persistent header information.
+		 */
+		lastoff = lp->lsn.offset;
+
+		/* Point the current LSN to the new file. */
+		++lp->lsn.file;
+		lp->lsn.offset = 0;
+
+		/* Reset the file write offset. */
+		lp->w_off = 0;
+	} else
+		lastoff = 0;
+
+	/* Initialize the LSN information returned to the user. */
+	lsn->file = lp->lsn.file;
+	lsn->offset = lp->lsn.offset;
+
+	/*
+	 * Insert persistent information as the first record in every file.
+	 * Note that the previous length is wrong for the very first record
+	 * of the log, but that's okay, we check for it during retrieval.
+	 */
+	if (lp->lsn.offset == 0) {
+		t.data = &lp->persist;
+		t.size = sizeof(LOGP);
+		if ((ret = __log_putr(dblp, lsn,
+		    &t, lastoff == 0 ? 0 : lastoff - lp->len)) != 0)
+			return (ret);
+
+		/*
+		 * Record files open in this log.
+		 * If we are recovering then we are in the
+		 * process of outputting the files, don't do
+		 * it again.
+		 */
+		if (!F_ISSET(dblp, DBLOG_RECOVER) &&
+		    (ret = __log_open_files(dbenv)) != 0)
+			return (ret);
+
+		/* Update the LSN information returned to the user. */
+		lsn->file = lp->lsn.file;
+		lsn->offset = lp->lsn.offset;
+	}
+
+	/* Write the application's log record. */
+	if ((ret = __log_putr(dblp, lsn, dbt, lp->lsn.offset - lp->len)) != 0)
+		return (ret);
+
+	/*
+	 * On a checkpoint, we:
+	 *	Put out the checkpoint record (above).
+	 *	Save the LSN of the checkpoint in the shared region.
+	 *	Append the set of file name information into the log.
+	 */
+	if (flags == DB_CHECKPOINT) {
+		lp->chkpt_lsn = *lsn;
+		if ((ret = __log_open_files(dbenv)) != 0)
+			return (ret);
+	}
+
+	/*
+	 * On a checkpoint or when flush is requested, we:
+	 *	Flush the current buffer contents to disk.
+	 *	Sync the log to disk.
+	 */
+	if (flags == DB_FLUSH || flags == DB_CHECKPOINT)
+		if ((ret = __log_flush(dblp, NULL)) != 0)
+			return (ret);
+
+	/*
+	 * On a checkpoint, we:
+	 *	Save the time the checkpoint was written.
+	 *	Reset the bytes written since the last checkpoint.
+	 */
+	if (flags == DB_CHECKPOINT) {
+		(void)time(&lp->chkpt);
+		lp->stat.st_wc_bytes = lp->stat.st_wc_mbytes = 0;
+	}
+	return (0);
+}
+
+/*
+ * __log_putr --
+ *	Actually put a record into the log.
+ */
+static int
+__log_putr(dblp, lsn, dbt, prev)
+	DB_LOG *dblp;
+	DB_LSN *lsn;
+	const DBT *dbt;
+	u_int32_t prev;
+{
+	HDR hdr;
+	LOG *lp;
+	int ret;
+
+	lp = dblp->reginfo.primary;
+
+	/*
+	 * Initialize the header.  If we just switched files, lsn.offset will
+	 * be 0, and what we really want is the offset of the previous record
+	 * in the previous file.  Fortunately, prev holds the value we want.
+	 */
+	hdr.prev = prev;
+	hdr.len = sizeof(HDR) + dbt->size;
+	hdr.cksum = __ham_func4(NULL, dbt->data, dbt->size);
+
+	if ((ret = __log_fill(dblp, lsn, &hdr, sizeof(HDR))) != 0)
+		return (ret);
+	lp->len = sizeof(HDR);
+	lp->lsn.offset += sizeof(HDR);
+
+	if ((ret = __log_fill(dblp, lsn, dbt->data, dbt->size)) != 0)
+		return (ret);
+	lp->len += dbt->size;
+	lp->lsn.offset += dbt->size;
+	return (0);
+}
+
+/*
+ * log_flush --
+ *	Write all records less than or equal to the specified LSN.
+ */
+int
+log_flush(dbenv, lsn)
+	DB_ENV *dbenv;
+	const DB_LSN *lsn;
+{
+	DB_LOG *dblp;
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_flush(dbenv, lsn));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	dblp = dbenv->lg_handle;
+	R_LOCK(dbenv, &dblp->reginfo);
+	ret = __log_flush(dblp, lsn);
+	R_UNLOCK(dbenv, &dblp->reginfo);
+	return (ret);
+}
+
+/*
+ * __log_flush --
+ *	Write all records less than or equal to the specified LSN; internal
+ *	version.
+ */
+static int
+__log_flush(dblp, lsn)
+	DB_LOG *dblp;
+	const DB_LSN *lsn;
+{
+	DB_LSN t_lsn;
+	LOG *lp;
+	int current, ret;
+
+	ret = 0;
+	lp = dblp->reginfo.primary;
+
+	/*
+	 * If no LSN specified, flush the entire log by setting the flush LSN
+	 * to the last LSN written in the log.  Otherwise, check that the LSN
+	 * isn't a non-existent record for the log.
+	 */
+	if (lsn == NULL) {
+		t_lsn.file = lp->lsn.file;
+		t_lsn.offset = lp->lsn.offset - lp->len;
+		lsn = &t_lsn;
+	} else
+		if (lsn->file > lp->lsn.file ||
+		    (lsn->file == lp->lsn.file &&
+		    lsn->offset > lp->lsn.offset - lp->len)) {
+			__db_err(dblp->dbenv,
+			    "log_flush: LSN past current end-of-log");
+			return (EINVAL);
+		}
+
+	/*
+	 * If the LSN is less than or equal to the last-sync'd LSN, we're done.
+	 * Note, the last-sync LSN saved in s_lsn is the LSN of the first byte
+	 * after the byte we absolutely know was written to disk, so the test
+	 * is <, not <=.
+	 */
+	if (lsn->file < lp->s_lsn.file ||
+	    (lsn->file == lp->s_lsn.file && lsn->offset < lp->s_lsn.offset))
+		return (0);
+
+	/*
+	 * We may need to write the current buffer.  We have to write the
+	 * current buffer if the flush LSN is greater than or equal to the
+	 * buffer's starting LSN.
+	 */
+	current = 0;
+	if (lp->b_off != 0 && log_compare(lsn, &lp->f_lsn) >= 0) {
+		if ((ret = __log_write(dblp, dblp->bufp, lp->b_off)) != 0)
+			return (ret);
+
+		lp->b_off = 0;
+		current = 1;
+	}
+
+	/*
+	 * It's possible that this thread may never have written to this log
+	 * file.  Acquire a file descriptor if we don't already have one.
+	 * One last check -- if we're not writing anything from the current
+	 * buffer, don't bother.  We have nothing to write and nothing to
+	 * sync.
+	 */
+	if (dblp->lfname != lp->lsn.file) {
+		if (!current)
+			return (0);
+		if ((ret = __log_newfh(dblp)) != 0)
+			return (ret);
+	}
+
+	/* Sync all writes to disk. */
+	if ((ret = __os_fsync(dblp->dbenv, &dblp->lfh)) != 0)
+		return (__db_panic(dblp->dbenv, ret));
+	++lp->stat.st_scount;
+
+	/* Set the last-synced LSN, using the on-disk write offset. */
+	lp->s_lsn.file = lp->f_lsn.file;
+	lp->s_lsn.offset = lp->w_off;
+
+	return (0);
+}
+
+/*
+ * __log_fill --
+ *	Write information into the log.
+ */
+static int
+__log_fill(dblp, lsn, addr, len)
+	DB_LOG *dblp;
+	DB_LSN *lsn;
+	void *addr;
+	u_int32_t len;
+{
+	LOG *lp;
+	u_int32_t bsize, nrec;
+	size_t nw, remain;
+	int ret;
+
+	lp = dblp->reginfo.primary;
+	bsize = lp->buffer_size;
+
+	while (len > 0) {			/* Copy out the data. */
+		/*
+		 * If we're beginning a new buffer, note the user LSN to which
+		 * the first byte of the buffer belongs.  We have to know this
+		 * when flushing the buffer so that we know if the in-memory
+		 * buffer needs to be flushed.
+		 */
+		if (lp->b_off == 0)
+			lp->f_lsn = *lsn;
+
+		/*
+		 * If we're on a buffer boundary and the data is big enough,
+		 * copy as many records as we can directly from the data.
+		 */
+		if (lp->b_off == 0 && len >= bsize) {
+			nrec = len / bsize;
+			if ((ret = __log_write(dblp, addr, nrec * bsize)) != 0)
+				return (ret);
+			addr = (u_int8_t *)addr + nrec * bsize;
+			len -= nrec * bsize;
+			++lp->stat.st_wcount_fill;
+			continue;
+		}
+
+		/* Figure out how many bytes we can copy this time. */
+		remain = bsize - lp->b_off;
+		nw = remain > len ? len : remain;
+		memcpy(dblp->bufp + lp->b_off, addr, nw);
+		addr = (u_int8_t *)addr + nw;
+		len -= nw;
+		lp->b_off += nw;
+
+		/* If we fill the buffer, flush it. */
+		if (lp->b_off == bsize) {
+			if ((ret = __log_write(dblp, dblp->bufp, bsize)) != 0)
+				return (ret);
+			lp->b_off = 0;
+			++lp->stat.st_wcount_fill;
+		}
+	}
+	return (0);
+}
+
+/*
+ * __log_write --
+ *	Write the log buffer to disk.
+ */
+static int
+__log_write(dblp, addr, len)
+	DB_LOG *dblp;
+	void *addr;
+	u_int32_t len;
+{
+	LOG *lp;
+	size_t nw;
+	int ret;
+
+	/*
+	 * If we haven't opened the log file yet or the current one
+	 * has changed, acquire a new log file.
+	 */
+	lp = dblp->reginfo.primary;
+	if (!F_ISSET(&dblp->lfh, DB_FH_VALID) || dblp->lfname != lp->lsn.file)
+		if ((ret = __log_newfh(dblp)) != 0)
+			return (ret);
+
+	/*
+	 * Seek to the offset in the file (someone may have written it
+	 * since we last did).
+	 */
+	if ((ret =
+	    __os_seek(dblp->dbenv,
+	    &dblp->lfh, 0, 0, lp->w_off, 0, DB_OS_SEEK_SET)) != 0 ||
+	    (ret = __os_write(dblp->dbenv, &dblp->lfh, addr, len, &nw)) != 0)
+		return (__db_panic(dblp->dbenv, ret));
+	if (nw != len) {
+		__db_err(dblp->dbenv, "Short write while writing log");
+		return (EIO);
+	}
+
+	/* Reset the buffer offset and update the seek offset. */
+	lp->w_off += len;
+
+	/* Update written statistics. */
+	if ((lp->stat.st_w_bytes += len) >= MEGABYTE) {
+		lp->stat.st_w_bytes -= MEGABYTE;
+		++lp->stat.st_w_mbytes;
+	}
+	if ((lp->stat.st_wc_bytes += len) >= MEGABYTE) {
+		lp->stat.st_wc_bytes -= MEGABYTE;
+		++lp->stat.st_wc_mbytes;
+	}
+	++lp->stat.st_wcount;
+
+	return (0);
+}
+
+/*
+ * log_file --
+ *	Map a DB_LSN to a file name.
+ */
+int
+log_file(dbenv, lsn, namep, len)
+	DB_ENV *dbenv;
+	const DB_LSN *lsn;
+	char *namep;
+	size_t len;
+{
+	DB_LOG *dblp;
+	int ret;
+	char *name;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_file(dbenv, lsn, namep, len));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	dblp = dbenv->lg_handle;
+	R_LOCK(dbenv, &dblp->reginfo);
+	ret = __log_name(dblp, lsn->file, &name, NULL, 0);
+	R_UNLOCK(dbenv, &dblp->reginfo);
+	if (ret != 0)
+		return (ret);
+
+	/* Check to make sure there's enough room and copy the name. */
+	if (len < strlen(name) + 1) {
+		*namep = '\0';
+		__db_err(dbenv, "log_file: name buffer is too short");
+		return (EINVAL);
+	}
+	(void)strcpy(namep, name);
+	__os_freestr(name);
+
+	return (0);
+}
+
+/*
+ * __log_newfh --
+ *	Acquire a file handle for the current log file.
+ */
+static int
+__log_newfh(dblp)
+	DB_LOG *dblp;
+{
+	LOG *lp;
+	int ret;
+	char *name;
+
+	/* Close any previous file descriptor. */
+	if (F_ISSET(&dblp->lfh, DB_FH_VALID))
+		(void)__os_closehandle(&dblp->lfh);
+
+	/* Get the path of the new file and open it. */
+	lp = dblp->reginfo.primary;
+	dblp->lfname = lp->lsn.file;
+
+	/*
+	 * Adding DB_OSO_LOG to the flags may add additional platform-specific
+	 * optimizations.  On WinNT, the logfile is preallocated, which may
+	 * have a time penalty at startup, but have better overall throughput.
+	 * We are not certain that this works reliably, so enable at your own
+	 * risk.
+	 *
+	 * XXX:
+	 * Initialize the log file size.  This is a hack to push the log's
+	 * maximum size down into the Windows __os_open routine, because it
+	 * wants to pre-allocate it.
+	 */
+	dblp->lfh.log_size = dblp->dbenv->lg_max;
+	if ((ret = __log_name(dblp, dblp->lfname,
+	    &name, &dblp->lfh,
+	    DB_OSO_CREATE |/* DB_OSO_LOG |*/ DB_OSO_SEQ)) != 0)
+		__db_err(dblp->dbenv,
+		    "log_put: %s: %s", name, db_strerror(ret));
+
+	__os_freestr(name);
+	return (ret);
+}
+
+/*
+ * __log_name --
+ *	Return the log name for a particular file, and optionally open it.
+ *
+ * PUBLIC: int __log_name __P((DB_LOG *,
+ * PUBLIC:     u_int32_t, char **, DB_FH *, u_int32_t));
+ */
+int
+__log_name(dblp, filenumber, namep, fhp, flags)
+	DB_LOG *dblp;
+	u_int32_t filenumber, flags;
+	char **namep;
+	DB_FH *fhp;
+{
+	LOG *lp;
+	int ret;
+	char *oname;
+	char old[sizeof(LFPREFIX) + 5 + 20], new[sizeof(LFPREFIX) + 10 + 20];
+
+	lp = dblp->reginfo.primary;
+
+	/*
+	 * !!!
+	 * The semantics of this routine are bizarre.
+	 *
+	 * The reason for all of this is that we need a place where we can
+	 * intercept requests for log files, and, if appropriate, check for
+	 * both the old-style and new-style log file names.  The trick is
+	 * that all callers of this routine that are opening the log file
+	 * read-only want to use an old-style file name if they can't find
+	 * a match using a new-style name.  The only down-side is that some
+	 * callers may check for the old-style when they really don't need
+	 * to, but that shouldn't mess up anything, and we only check for
+	 * the old-style name when we've already failed to find a new-style
+	 * one.
+	 *
+	 * Create a new-style file name, and if we're not going to open the
+	 * file, return regardless.
+	 */
+	(void)snprintf(new, sizeof(new), LFNAME, filenumber);
+	if ((ret = __db_appname(dblp->dbenv,
+	    DB_APP_LOG, NULL, new, 0, NULL, namep)) != 0 || fhp == NULL)
+		return (ret);
+
+	/* Open the new-style file -- if we succeed, we're done. */
+	if ((ret = __os_open(dblp->dbenv,
+	    *namep, flags, lp->persist.mode, fhp)) == 0)
+		return (0);
+
+	/*
+	 * The open failed... if the DB_RDONLY flag isn't set, we're done,
+	 * the caller isn't interested in old-style files.
+	 */
+	if (!LF_ISSET(DB_OSO_RDONLY)) {
+		__db_err(dblp->dbenv,
+		    "%s: log file open failed: %s", *namep, db_strerror(ret));
+		return (__db_panic(dblp->dbenv, ret));
+	}
+
+	/* Create an old-style file name. */
+	(void)snprintf(old, sizeof(old), LFNAME_V1, filenumber);
+	if ((ret = __db_appname(dblp->dbenv,
+	    DB_APP_LOG, NULL, old, 0, NULL, &oname)) != 0)
+		goto err;
+
+	/*
+	 * Open the old-style file -- if we succeed, we're done.  Free the
+	 * space allocated for the new-style name and return the old-style
+	 * name to the caller.
+	 */
+	if ((ret = __os_open(dblp->dbenv,
+	    oname, flags, lp->persist.mode, fhp)) == 0) {
+		__os_freestr(*namep);
+		*namep = oname;
+		return (0);
+	}
+
+	/*
+	 * Couldn't find either style of name -- return the new-style name
+	 * for the caller's error message.  If it's an old-style name that's
+	 * actually missing we're going to confuse the user with the error
+	 * message, but that implies that not only were we looking for an
+	 * old-style name, but we expected it to exist and we weren't just
+	 * looking for any log file.  That's not a likely error.
+	 */
+err:	__os_freestr(oname);
+	return (ret);
+}
+
+static int
+__log_open_files(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_LOG *dblp;
+	DB_LSN r_unused;
+	DBT fid_dbt, t;
+	FNAME *fnp;
+	LOG *lp;
+	int ret;
+
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+
+	for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+	    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
+		if (fnp->ref == 0)	/* Entry not in use. */
+			continue;
+		if (fnp->name_off != INVALID_ROFF) {
+			memset(&t, 0, sizeof(t));
+			t.data = R_ADDR(&dblp->reginfo, fnp->name_off);
+			t.size = strlen(t.data) + 1;
+		}
+		memset(&fid_dbt, 0, sizeof(fid_dbt));
+		fid_dbt.data = fnp->ufid;
+		fid_dbt.size = DB_FILE_ID_LEN;
+		/*
+		 * Output LOG_CHECKPOINT records which will be
+		 * processed during the OPENFILES pass of recovery.
+		 * At the end of recovery we want to output the
+		 * files that were open so that a future recovery
+		 * run will have the correct files open during
+		 * a backward pass.  For this we output LOG_CLOSE
+		 * records so that the files will be closed on
+		 * the forward pass.
+		 */
+		if ((ret = __log_register_log(dbenv,
+		    NULL, &r_unused, 0,
+		    F_ISSET(dblp, DBLOG_RECOVER) ? LOG_CLOSE : LOG_CHECKPOINT,
+		    fnp->name_off == INVALID_ROFF ? NULL : &t,
+		    &fid_dbt, fnp->id, fnp->s_type, fnp->meta_pgno)) != 0)
+			return (ret);
+	}
+	return (0);
+}
diff --git a/bdb/log/log_rec.c b/bdb/log/log_rec.c
new file mode 100644
index 00000000000..a871848295e
--- /dev/null
+++ b/bdb/log/log_rec.c
@@ -0,0 +1,621 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+/*
+ * Copyright (c) 1995, 1996
+ *	The President and Fellows of Harvard University.  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. 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.
+ */
+
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_rec.c,v 11.48 2001/01/11 18:19:53 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#endif
+
+#include "db_int.h"
+#include "db_page.h"
+#include "db_am.h"
+#include "log.h"
+
+static int __log_do_open __P((DB_ENV *, DB_LOG *,
+    u_int8_t *, char *, DBTYPE, int32_t, db_pgno_t));
+static int __log_open_file __P((DB_ENV *, DB_LOG *, __log_register_args *));
+
+/*
+ * PUBLIC: int __log_register_recover
+ * PUBLIC:     __P((DB_ENV *, DBT *, DB_LSN *, db_recops, void *));
+ */
+int
+__log_register_recover(dbenv, dbtp, lsnp, op, info)
+	DB_ENV *dbenv;
+	DBT *dbtp;
+	DB_LSN *lsnp;
+	db_recops op;
+	void *info;
+{
+	DB_ENTRY *dbe;
+	DB_LOG *logp;
+	DB *dbp;
+	__log_register_args *argp;
+	int do_rem, ret, t_ret;
+
+	logp = dbenv->lg_handle;
+	dbp = NULL;
+
+#ifdef DEBUG_RECOVER
+	REC_PRINT(__log_register_print);
+#endif
+	COMPQUIET(lsnp, NULL);
+
+	if ((ret = __log_register_read(dbenv, dbtp->data, &argp)) != 0)
+		goto out;
+
+	if ((argp->opcode == LOG_OPEN &&
+	    (DB_REDO(op) || op == DB_TXN_OPENFILES)) ||
+	    (argp->opcode == LOG_CLOSE && DB_UNDO(op))) {
+		/*
+		 * If we are redoing an open or undoing a close, then we need
+		 * to open a file.  We must open the file even if
+		 * the meta page is not yet written as we may be creating it.
+		 */
+		if (op == DB_TXN_OPENFILES)
+			F_SET(logp, DBLOG_FORCE_OPEN);
+		ret = __log_open_file(dbenv, logp, argp);
+		F_CLR(logp, DBLOG_FORCE_OPEN);
+		if (ret == ENOENT || ret == EINVAL) {
+			if (op == DB_TXN_OPENFILES && argp->name.size != 0 &&
+			    (ret = __db_txnlist_delete(dbenv, info,
+				argp->name.data, argp->fileid, 0)) != 0)
+				goto out;
+			ret = 0;
+		}
+	} else if (argp->opcode != LOG_CHECKPOINT) {
+		/*
+		 * If we are undoing an open, then we need to close the file.
+		 *
+		 * If the file is deleted, then we can just ignore this close.
+		 * Otherwise, we should usually have a valid dbp we should
+		 * close or whose reference count should be decremented.
+		 * However, if we shut down without closing a file, we may, in
+		 * fact, not have the file open, and that's OK.
+		 */
+		do_rem = 0;
+		MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
+		if (argp->fileid < logp->dbentry_cnt) {
+			dbe = &logp->dbentry[argp->fileid];
+
+			DB_ASSERT(dbe->refcount == 1);
+
+			ret = __db_txnlist_close(info,
+			    argp->fileid, dbe->count);
+			if ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL)
+				(void)log_unregister(dbenv, dbp);
+			do_rem = 1;
+		}
+		MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
+		if (do_rem) {
+			(void)__log_rem_logid(logp, dbp, argp->fileid);
+			/*
+			 * If remove or rename has closed the file, don't
+			 * sync.
+			 */
+			if (dbp != NULL &&
+			    (t_ret = dbp->close(dbp,
+			    dbp->mpf == NULL ? DB_NOSYNC : 0)) != 0 && ret == 0)
+				ret = t_ret;
+		}
+	} else if (DB_UNDO(op) || op == DB_TXN_OPENFILES) {
+		/*
+		 * It's a checkpoint and we are rolling backward.  It
+		 * is possible that the system was shut down and thus
+		 * ended with a stable checkpoint; this file was never
+		 * closed and has therefore not been reopened yet.  If
+		 * so, we need to try to open it.
+		 */
+		ret = __log_open_file(dbenv, logp, argp);
+		if (ret == ENOENT || ret == EINVAL) {
+			if (argp->name.size != 0 && (ret =
+			    __db_txnlist_delete(dbenv, info,
+				argp->name.data, argp->fileid, 0)) != 0)
+				goto out;
+			ret = 0;
+		}
+	}
+
+out:	if (argp != NULL)
+		__os_free(argp, 0);
+	return (ret);
+}
+
+/*
+ * __log_open_file --
+ *	Called during log_register recovery.  Make sure that we have an
+ *	entry in the dbentry table for this ndx.  Returns 0 on success,
+ *	non-zero on error.
+ */
+static int
+__log_open_file(dbenv, lp, argp)
+	DB_ENV *dbenv;
+	DB_LOG *lp;
+	__log_register_args *argp;
+{
+	DB_ENTRY *dbe;
+	DB *dbp;
+
+	/*
+	 * We never re-open temporary files.  Temp files are only
+	 * useful during aborts in which case the dbp was entered
+	 * when the file was registered.  During recovery, we treat
+	 * temp files as properly deleted files, allowing the open to
+	 * fail and not reporting any errors when recovery fails to
+	 * get a valid dbp from db_fileid_to_db.
+	 */
+	if (argp->name.size == 0) {
+		(void)__log_add_logid(dbenv, lp, NULL, argp->fileid);
+		return (ENOENT);
+	}
+
+	/*
+	 * Because of reference counting, we cannot automatically close files
+	 * during recovery, so when we're opening, we have to check that the
+	 * name we are opening is what we expect.  If it's not, then we close
+	 * the old file and open the new one.
+	 */
+	MUTEX_THREAD_LOCK(dbenv, lp->mutexp);
+	if (argp->fileid < lp->dbentry_cnt)
+		dbe = &lp->dbentry[argp->fileid];
+	else
+		dbe = NULL;
+
+	if (dbe != NULL) {
+		dbe->deleted = 0;
+		if ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL) {
+			if (dbp->meta_pgno != argp->meta_pgno ||
+			    memcmp(dbp->fileid,
+			    argp->uid.data, DB_FILE_ID_LEN) != 0) {
+				MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
+				goto reopen;
+			}
+			if (!F_ISSET(lp, DBLOG_RECOVER))
+				dbe->refcount++;
+			MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
+			return (0);
+		}
+	}
+
+	MUTEX_THREAD_UNLOCK(dbenv, lp->mutexp);
+	if (0) {
+reopen:		(void)log_unregister(dbp->dbenv, dbp);
+		(void)__log_rem_logid(lp, dbp, argp->fileid);
+		dbp->close(dbp, 0);
+	}
+
+	return (__log_do_open(dbenv, lp,
+	    argp->uid.data, argp->name.data,
+	    argp->ftype, argp->fileid, argp->meta_pgno));
+}
+
+/*
+ * log_reopen_file -- close and reopen a db file.
+ *	Must be called when a metadata page changes.
+ *
+ * PUBLIC: int __log_reopen_file __P((DB_ENV *,
+ * PUBLIC:     char *, int32_t, u_int8_t *, db_pgno_t));
+ *
+ */
+int
+__log_reopen_file(dbenv, name, ndx, fileid, meta_pgno)
+	DB_ENV *dbenv;
+	char *name;
+	int32_t ndx;
+	u_int8_t *fileid;
+	db_pgno_t meta_pgno;
+{
+	DB *dbp;
+	DB_LOG *logp;
+	DBTYPE ftype;
+	FNAME *fnp;
+	LOG *lp;
+	char *tmp_name;
+	int ret;
+
+	logp = dbenv->lg_handle;
+
+	if (name == NULL) {
+		R_LOCK(dbenv, &logp->reginfo);
+
+		lp = logp->reginfo.primary;
+
+		for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+		    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
+			if (fnp->ref == 0)      /* Entry not in use. */
+				continue;
+			if (memcmp(fnp->ufid, fileid, DB_FILE_ID_LEN) == 0)
+				break;
+		}
+
+		if (fnp == 0 || fnp->name_off == INVALID_ROFF) {
+			__db_err(dbenv,
+			    "metasub recover: non-existent file id");
+			return (EINVAL);
+		}
+
+		name = R_ADDR(&logp->reginfo, fnp->name_off);
+		ret = __os_strdup(dbenv, name, &tmp_name);
+		R_UNLOCK(dbenv, &logp->reginfo);
+		if (ret != 0)
+			goto out;
+		name = tmp_name;
+	} else
+		tmp_name = NULL;
+
+	if ((ret = __db_fileid_to_db(dbenv, &dbp, ndx, 0)) != 0)
+		goto out;
+	ftype = dbp->type;
+	(void)log_unregister(dbenv, dbp);
+	(void)__log_rem_logid(logp, dbp, ndx);
+	(void)dbp->close(dbp, 0);
+
+	ret = __log_do_open(dbenv, logp, fileid, name, ftype, ndx, meta_pgno);
+
+	if (tmp_name != NULL)
+		__os_free(tmp_name, 0);
+
+out:	return (ret);
+}
+
+/*
+ * __log_do_open --
+ *	Open files referenced in the log.  This is the part of the open that
+ * is not protected by the thread mutex.
+ */
+static int
+__log_do_open(dbenv, lp, uid, name, ftype, ndx, meta_pgno)
+	DB_ENV *dbenv;
+	DB_LOG *lp;
+	u_int8_t *uid;
+	char *name;
+	DBTYPE ftype;
+	int32_t ndx;
+	db_pgno_t meta_pgno;
+{
+	DB *dbp;
+	int ret;
+	u_int8_t zeroid[DB_FILE_ID_LEN];
+
+	if ((ret = db_create(&dbp, lp->dbenv, 0)) != 0)
+		return (ret);
+
+	dbp->log_fileid = ndx;
+
+	/*
+	 * This is needed to signal to the locking routines called while
+	 * opening databases that we are potentially undoing a transaction
+	 * from an XA process.  Since the XA process does not share
+	 * locks with the aborting transaction this prevents us from
+	 * deadlocking during the open during rollback.
+	 * Because this routine is called either during recovery or during an
+	 * XA_ABORT, we can safely set DB_AM_RECOVER in the dbp since it
+	 * will not be shared with other threads.
+	 */
+	F_SET(dbp, DB_AM_RECOVER);
+	if (meta_pgno != PGNO_BASE_MD)
+		memcpy(dbp->fileid, uid, DB_FILE_ID_LEN);
+	dbp->type = ftype;
+	if ((ret =
+	    __db_dbopen(dbp, name, 0, __db_omode("rw----"), meta_pgno)) == 0) {
+		/*
+		 * Verify that we are opening the same file that we were
+		 * referring to when we wrote this log record.
+		 */
+		if (memcmp(uid, dbp->fileid, DB_FILE_ID_LEN) != 0) {
+			memset(zeroid, 0, DB_FILE_ID_LEN);
+			if (memcmp(dbp->fileid, zeroid, DB_FILE_ID_LEN) != 0)
+				goto not_right;
+			memcpy(dbp->fileid, uid, DB_FILE_ID_LEN);
+		}
+		if (IS_RECOVERING(dbenv)) {
+			(void)log_register(dbp->dbenv, dbp, name);
+			(void)__log_add_logid(dbenv, lp, dbp, ndx);
+		}
+		return (0);
+	}
+
+not_right:
+	(void)dbp->close(dbp, 0);
+	(void)__log_add_logid(dbenv, lp, NULL, ndx);
+
+	return (ENOENT);
+}
+
+/*
+ * __log_add_logid --
+ *	Adds a DB entry to the log's DB entry table.
+ *
+ * PUBLIC: int __log_add_logid __P((DB_ENV *, DB_LOG *, DB *, int32_t));
+ */
+int
+__log_add_logid(dbenv, logp, dbp, ndx)
+	DB_ENV *dbenv;
+	DB_LOG *logp;
+	DB *dbp;
+	int32_t ndx;
+{
+	DB *dbtmp;
+	int32_t i;
+	int ret;
+
+	ret = 0;
+
+	MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
+
+	/*
+	 * Check if we need to grow the table.  Note, ndx is 0-based (the
+	 * index into the DB entry table) an dbentry_cnt is 1-based, the
+	 * number of available slots.
+	 */
+	if (logp->dbentry_cnt <= ndx) {
+		if ((ret = __os_realloc(dbenv,
+		    (ndx + DB_GROW_SIZE) * sizeof(DB_ENTRY),
+		    NULL, &logp->dbentry)) != 0)
+			goto err;
+
+		/*
+		 * We have moved the head of the queue.
+		 * Fix up the queue header of an empty queue or the previous
+		 * pointer of the first element.
+		 */
+		for (i = 0; i < logp->dbentry_cnt; i++) {
+			if ((dbtmp =
+			    TAILQ_FIRST(&logp->dbentry[i].dblist)) == NULL)
+				TAILQ_INIT(&logp->dbentry[i].dblist);
+			else
+				TAILQ_REINSERT_HEAD(
+				    &logp->dbentry[i].dblist, dbp, links);
+		}
+
+		/* Initialize the new entries. */
+		for (i = logp->dbentry_cnt; i < ndx + DB_GROW_SIZE; i++) {
+			logp->dbentry[i].count = 0;
+			TAILQ_INIT(&logp->dbentry[i].dblist);
+			logp->dbentry[i].deleted = 0;
+			logp->dbentry[i].refcount = 0;
+		}
+
+		logp->dbentry_cnt = i;
+	}
+
+	if (logp->dbentry[ndx].deleted == 0 &&
+	    TAILQ_FIRST(&logp->dbentry[ndx].dblist) == NULL) {
+		logp->dbentry[ndx].count = 0;
+		if (dbp != NULL)
+			TAILQ_INSERT_HEAD(&logp->dbentry[ndx].dblist,
+			    dbp, links);
+		logp->dbentry[ndx].deleted = dbp == NULL;
+		logp->dbentry[ndx].refcount = 1;
+	} else if (!F_ISSET(logp, DBLOG_RECOVER)) {
+		if (dbp != NULL)
+			TAILQ_INSERT_HEAD(&logp->dbentry[ndx].dblist,
+			    dbp, links);
+		logp->dbentry[ndx].refcount++;
+	}
+
+err:	MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
+	return (ret);
+}
+
+/*
+ * __db_fileid_to_db --
+ *	Return the DB corresponding to the specified fileid.
+ *
+ * PUBLIC: int __db_fileid_to_db __P((DB_ENV *, DB **, int32_t, int));
+ */
+int
+__db_fileid_to_db(dbenv, dbpp, ndx, inc)
+	DB_ENV *dbenv;
+	DB **dbpp;
+	int32_t ndx;
+	int inc;
+{
+	DB_LOG *logp;
+	DB *dbp;
+	FNAME *fname;
+	int ret;
+	char *name;
+
+	ret = 0;
+	logp = dbenv->lg_handle;
+
+	MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
+
+	/*
+	 * Under XA, a process different than the one issuing DB operations
+	 * may abort a transaction.  In this case, recovery routines are run
+	 * by a process that does not necessarily have the file open, so we
+	 * we must open the file explicitly.
+	 */
+	if (ndx >= logp->dbentry_cnt ||
+	    (!logp->dbentry[ndx].deleted &&
+	    (dbp = TAILQ_FIRST(&logp->dbentry[ndx].dblist)) == NULL)) {
+		if (F_ISSET(logp, DBLOG_RECOVER)) {
+			ret = ENOENT;
+			goto err;
+		}
+		if (__log_lid_to_fname(logp, ndx, &fname) != 0) {
+			/* Couldn't find entry; this is a fatal error. */
+			__db_err(dbenv, "Missing log fileid entry");
+			ret = EINVAL;
+			goto err;
+		}
+		name = R_ADDR(&logp->reginfo, fname->name_off);
+
+		/*
+		 * __log_do_open is called without protection of the
+		 * log thread lock.
+		 */
+		MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
+
+		/*
+		 * At this point, we are not holding the thread lock, so exit
+		 * directly instead of going through the exit code at the
+		 * bottom.  If the __log_do_open succeeded, then we don't need
+		 * to do any of the remaining error checking at the end of this
+		 * routine.
+		 */
+		if ((ret = __log_do_open(dbenv, logp,
+		    fname->ufid, name, fname->s_type,
+		    ndx, fname->meta_pgno)) != 0)
+			return (ret);
+
+		*dbpp = TAILQ_FIRST(&logp->dbentry[ndx].dblist);
+		return (0);
+	}
+
+	/*
+	 * Return DB_DELETED if the file has been deleted (it's not an error).
+	 */
+	if (logp->dbentry[ndx].deleted) {
+		ret = DB_DELETED;
+		if (inc)
+			logp->dbentry[ndx].count++;
+		goto err;
+	}
+
+	/*
+	 * Otherwise return 0, but if we don't have a corresponding DB, it's
+	 * an error.
+	 */
+	if ((*dbpp = TAILQ_FIRST(&logp->dbentry[ndx].dblist)) == NULL)
+		ret = ENOENT;
+
+err:	MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
+	return (ret);
+}
+
+/*
+ * __log_close_files --
+ *	Close files that were opened by the recovery daemon.  We sync the
+ *	file, unless its mpf pointer has been NULLed by a db_remove or
+ *	db_rename.  We may not have flushed the log_register record that
+ *	closes the file.
+ *
+ * PUBLIC: void __log_close_files __P((DB_ENV *));
+ */
+void
+__log_close_files(dbenv)
+	DB_ENV *dbenv;
+{
+	DB_ENTRY *dbe;
+	DB_LOG *logp;
+	DB *dbp;
+	int32_t i;
+
+	logp = dbenv->lg_handle;
+	MUTEX_THREAD_LOCK(dbenv, logp->mutexp);
+	for (i = 0; i < logp->dbentry_cnt; i++) {
+		dbe = &logp->dbentry[i];
+		while ((dbp = TAILQ_FIRST(&dbe->dblist)) != NULL) {
+			(void)log_unregister(dbenv, dbp);
+			TAILQ_REMOVE(&dbe->dblist, dbp, links);
+			(void)dbp->close(dbp, dbp->mpf == NULL ? DB_NOSYNC : 0);
+		}
+		dbe->deleted = 0;
+		dbe->refcount = 0;
+	}
+	MUTEX_THREAD_UNLOCK(dbenv, logp->mutexp);
+}
+
+/*
+ * __log_rem_logid
+ *	Remove an entry from the log table.  Find the appropriate DB and
+ * unlink it from the linked list off the table.  If the DB is NULL, treat
+ * this as a simple refcount decrement.
+ *
+ * PUBLIC: void __log_rem_logid __P((DB_LOG *, DB *, int32_t));
+ */
+void
+__log_rem_logid(logp, dbp, ndx)
+	DB_LOG *logp;
+	DB *dbp;
+	int32_t ndx;
+{
+	DB *xdbp;
+
+	MUTEX_THREAD_LOCK(logp->dbenv, logp->mutexp);
+	if (--logp->dbentry[ndx].refcount == 0) {
+		TAILQ_INIT(&logp->dbentry[ndx].dblist);
+		logp->dbentry[ndx].deleted = 0;
+	} else if (dbp != NULL)
+		for (xdbp = TAILQ_FIRST(&logp->dbentry[ndx].dblist);
+		    xdbp != NULL;
+		    xdbp = TAILQ_NEXT(xdbp, links))
+			if (xdbp == dbp) {
+				TAILQ_REMOVE(&logp->dbentry[ndx].dblist,
+				    xdbp, links);
+				break;
+			}
+
+	MUTEX_THREAD_UNLOCK(logp->dbenv, logp->mutexp);
+}
+
+/*
+ * __log_lid_to_fname --
+ *	Traverse the shared-memory region looking for the entry that
+ *	matches the passed log fileid.  Returns 0 on success; -1 on error.
+ * PUBLIC: int __log_lid_to_fname __P((DB_LOG *, int32_t, FNAME **));
+ */
+int
+__log_lid_to_fname(dblp, lid, fnamep)
+	DB_LOG *dblp;
+	int32_t lid;
+	FNAME **fnamep;
+{
+	FNAME *fnp;
+	LOG *lp;
+
+	lp = dblp->reginfo.primary;
+
+	for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+	    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
+		if (fnp->ref == 0)	/* Entry not in use. */
+			continue;
+		if (fnp->id == lid) {
+			*fnamep = fnp;
+			return (0);
+		}
+	}
+	return (-1);
+}
diff --git a/bdb/log/log_register.c b/bdb/log/log_register.c
new file mode 100644
index 00000000000..1e0e523d8b9
--- /dev/null
+++ b/bdb/log/log_register.c
@@ -0,0 +1,433 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997, 1998, 1999, 2000
+ *	Sleepycat Software.  All rights reserved.
+ */
+#include "db_config.h"
+
+#ifndef lint
+static const char revid[] = "$Id: log_register.c,v 11.35 2001/01/10 16:04:19 bostic Exp $";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+
+#include <string.h>
+#endif
+
+#ifdef  HAVE_RPC
+#include "db_server.h"
+#endif
+
+#include "db_int.h"
+#include "log.h"
+
+#ifdef HAVE_RPC
+#include "gen_client_ext.h"
+#include "rpc_client_ext.h"
+#endif
+
+/*
+ * log_register --
+ *	Register a file name.
+ */
+int
+log_register(dbenv, dbp, name)
+	DB_ENV *dbenv;
+	DB *dbp;
+	const char *name;
+{
+	DBT fid_dbt, r_name;
+	DB_LOG *dblp;
+	DB_LSN r_unused;
+	FNAME *found_fnp, *fnp, *recover_fnp, *reuse_fnp;
+	LOG *lp;
+	size_t len;
+	int32_t maxid;
+	int inserted, ok, ret;
+	void *namep;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_register(dbenv, dbp, name));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+	fnp = reuse_fnp = NULL;
+	inserted = ret = 0;
+	namep = NULL;
+
+	/* Check the arguments. */
+	if (dbp->type != DB_BTREE && dbp->type != DB_QUEUE &&
+	    dbp->type != DB_HASH && dbp->type != DB_RECNO) {
+		__db_err(dbenv, "log_register: unknown DB file type");
+		return (EINVAL);
+	}
+
+	R_LOCK(dbenv, &dblp->reginfo);
+
+	/*
+	 * See if we've already got this file in the log, finding the
+	 * (maximum+1) in-use file id and some available file id (if we
+	 * find an available fid, we'll use it, else we'll have to allocate
+	 * one after the maximum that we found).
+	 */
+	ok = 0;
+	found_fnp = recover_fnp = NULL;
+	for (maxid = 0, fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+	    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
+		if (F_ISSET(dblp, DBLOG_RECOVER) && fnp->id == dbp->log_fileid)
+			recover_fnp = fnp;
+		if (fnp->ref == 0) {		/* Entry is not in use. */
+			if (reuse_fnp == NULL)
+				reuse_fnp = fnp;
+			continue;
+		}
+		if (memcmp(dbp->fileid, fnp->ufid, DB_FILE_ID_LEN) == 0) {
+			if (fnp->meta_pgno == 0) {
+				if (fnp->locked == 1) {
+					__db_err(dbenv, "File is locked");
+					return (EINVAL);
+				}
+				if (found_fnp != NULL) {
+					fnp = found_fnp;
+					goto found;
+				}
+				ok = 1;
+			}
+			if (dbp->meta_pgno == fnp->meta_pgno) {
+				if (F_ISSET(dblp, DBLOG_RECOVER)) {
+					if (fnp->id != dbp->log_fileid) {
+						/*
+						 * If we are in recovery, there
+						 * is only one dbp on the list.
+						 * If the refcount goes to 0,
+						 * we will clear the list.  If
+						 * it doesn't, we want to leave
+						 * the dbp where it is, so
+						 * passing a NULL to rem_logid
+						 * is correct.
+						 */
+						__log_rem_logid(dblp,
+						    NULL, fnp->id);
+						if (recover_fnp != NULL)
+							break;
+						continue;
+					}
+					fnp->ref = 1;
+					goto found;
+				}
+				++fnp->ref;
+				if (ok)
+					goto found;
+				found_fnp = fnp;
+			}
+		}
+		if (maxid <= fnp->id)
+			maxid = fnp->id + 1;
+	}
+	if ((fnp = found_fnp) != NULL)
+		goto found;
+
+	/* Fill in fnp structure. */
+	if (recover_fnp != NULL)	/* This has the right number */
+		fnp = recover_fnp;
+	else if (reuse_fnp != NULL)	/* Reuse existing one. */
+		fnp = reuse_fnp;
+	else {				/* Allocate a new one. */
+		if ((ret = __db_shalloc(dblp->reginfo.addr,
+		    sizeof(FNAME), 0, &fnp)) != 0)
+			goto mem_err;
+		fnp->id = maxid;
+	}
+
+	if (F_ISSET(dblp, DBLOG_RECOVER))
+		fnp->id = dbp->log_fileid;
+
+	fnp->ref = 1;
+	fnp->locked = 0;
+	fnp->s_type = dbp->type;
+	memcpy(fnp->ufid, dbp->fileid, DB_FILE_ID_LEN);
+	fnp->meta_pgno = dbp->meta_pgno;
+
+	if (name != NULL) {
+		len = strlen(name) + 1;
+		if ((ret =
+		    __db_shalloc(dblp->reginfo.addr, len, 0, &namep)) != 0) {
+mem_err:		__db_err(dbenv,
+			    "Unable to allocate memory to register %s", name);
+			goto err;
+	}
+		fnp->name_off = R_OFFSET(&dblp->reginfo, namep);
+		memcpy(namep, name, len);
+	} else
+		fnp->name_off = INVALID_ROFF;
+
+	/* Only do the insert if we allocated a new fnp. */
+	if (reuse_fnp == NULL && recover_fnp == NULL)
+		SH_TAILQ_INSERT_HEAD(&lp->fq, fnp, q, __fname);
+	inserted = 1;
+
+	/* Log the registry. */
+	if (!F_ISSET(dblp, DBLOG_RECOVER)) {
+		/*
+		 * We allow logging on in-memory databases, so the name here
+		 * could be NULL.
+		 */
+		if (name != NULL) {
+			r_name.data = (void *)name;
+			r_name.size = strlen(name) + 1;
+		}
+		memset(&fid_dbt, 0, sizeof(fid_dbt));
+		fid_dbt.data = dbp->fileid;
+		fid_dbt.size = DB_FILE_ID_LEN;
+		if ((ret = __log_register_log(dbenv, NULL, &r_unused,
+		    0, LOG_OPEN, name == NULL ? NULL : &r_name,
+		    &fid_dbt, fnp->id, dbp->type, dbp->meta_pgno)) != 0)
+			goto err;
+	}
+
+found:	/*
+	 * If we found the entry in the shared area, then the file is
+	 * already open, so there is no need to log the open.  We only
+	 * log the open and closes on the first open and last close.
+	 */
+	if (!F_ISSET(dblp, DBLOG_RECOVER) &&
+	    (ret = __log_add_logid(dbenv, dblp, dbp, fnp->id)) != 0)
+			goto err;
+
+	if (!F_ISSET(dblp, DBLOG_RECOVER))
+		dbp->log_fileid = fnp->id;
+
+	if (0) {
+err:		if (inserted)
+			SH_TAILQ_REMOVE(&lp->fq, fnp, q, __fname);
+		if (namep != NULL)
+			__db_shalloc_free(dblp->reginfo.addr, namep);
+		if (fnp != NULL)
+			__db_shalloc_free(dblp->reginfo.addr, fnp);
+	}
+
+	R_UNLOCK(dbenv, &dblp->reginfo);
+
+	return (ret);
+}
+
+/*
+ * log_unregister --
+ *	Discard a registered file name.
+ */
+int
+log_unregister(dbenv, dbp)
+	DB_ENV *dbenv;
+	DB *dbp;
+{
+	int ret;
+
+#ifdef HAVE_RPC
+	if (F_ISSET(dbenv, DB_ENV_RPCCLIENT))
+		return (__dbcl_log_unregister(dbenv, dbp));
+#endif
+
+	PANIC_CHECK(dbenv);
+	ENV_REQUIRES_CONFIG(dbenv, dbenv->lg_handle, DB_INIT_LOG);
+
+	ret = __log_filelist_update(dbenv, dbp, dbp->log_fileid, NULL, NULL);
+	dbp->log_fileid = DB_LOGFILEID_INVALID;
+	return (ret);
+}
+
+/*
+ * PUBLIC: int __log_filelist_update
+ * PUBLIC:    __P((DB_ENV *, DB *, int32_t, const char *, int *));
+ *
+ *  Utility player for updating and logging the file list.  Called
+ *  for 3 reasons:
+ *	1) mark file closed: newname == NULL.
+ *	2) change filename: newname != NULL.
+ *	3) from recovery to verify & change filename if necessary, set != NULL.
+ */
+int
+__log_filelist_update(dbenv, dbp, fid, newname, set)
+	DB_ENV *dbenv;
+	DB *dbp;
+	int32_t fid;
+	const char *newname;
+	int *set;
+{
+	DBT fid_dbt, r_name;
+	DB_LOG *dblp;
+	DB_LSN r_unused;
+	FNAME *fnp;
+	LOG *lp;
+	u_int32_t len, newlen;
+	int ret;
+	void *namep;
+
+	ret = 0;
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+
+	R_LOCK(dbenv, &dblp->reginfo);
+
+	/* Find the entry in the log. */
+	for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+	    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname))
+		if (fid == fnp->id)
+			break;
+	if (fnp == NULL) {
+		__db_err(dbenv, "log_unregister: non-existent file id");
+		ret = EINVAL;
+		goto ret1;
+	}
+
+	/*
+	 * Log the unregistry only if this is the last one and we are
+	 * really closing the file or if this is an abort of a created
+	 * file and we need to make sure there is a record in the log.
+	 */
+	namep = NULL;
+	len = 0;
+	if (fnp->name_off != INVALID_ROFF) {
+		namep = R_ADDR(&dblp->reginfo, fnp->name_off);
+		len = strlen(namep) + 1;
+	}
+	if (!F_ISSET(dblp, DBLOG_RECOVER) && fnp->ref == 1) {
+		if (namep != NULL) {
+			memset(&r_name, 0, sizeof(r_name));
+			r_name.data = namep;
+			r_name.size = len;
+		}
+		memset(&fid_dbt, 0, sizeof(fid_dbt));
+		fid_dbt.data = fnp->ufid;
+		fid_dbt.size = DB_FILE_ID_LEN;
+		if ((ret = __log_register_log(dbenv, NULL, &r_unused,
+		    0, LOG_CLOSE,
+		    fnp->name_off == INVALID_ROFF ? NULL : &r_name,
+		    &fid_dbt, fid, fnp->s_type, fnp->meta_pgno))
+		    != 0)
+			goto ret1;
+	}
+
+	/*
+	 * If we are changing the name we must log this fact.
+	 */
+	if (newname != NULL) {
+		DB_ASSERT(fnp->ref == 1);
+		newlen = strlen(newname) + 1;
+		if (!F_ISSET(dblp, DBLOG_RECOVER)) {
+			r_name.data = (void *) newname;
+			r_name.size = newlen;
+			if ((ret = __log_register_log(dbenv,
+			    NULL, &r_unused, 0, LOG_OPEN, &r_name, &fid_dbt,
+			    fnp->id, fnp->s_type, fnp->meta_pgno)) != 0)
+				goto ret1;
+		}
+
+		/*
+		 * Check to see if the name is already correct.
+		 */
+		if (set != NULL) {
+			if (len != newlen || memcmp(namep, newname, len) != 0)
+				*set = 1;
+			else {
+				*set = 0;
+				goto ret1;
+			}
+		}
+
+		/*
+		 * Change the name, realloc memory if necessary
+		 */
+		if (len < newlen) {
+			__db_shalloc_free(dblp->reginfo.addr,
+			    R_ADDR(&dblp->reginfo, fnp->name_off));
+			if ((ret = __db_shalloc(
+			    dblp->reginfo.addr, newlen, 0, &namep)) != 0) {
+				__db_err(dbenv,
+				    "Unable to allocate memory to register %s",
+				    newname);
+				goto ret1;
+			}
+			fnp->name_off = R_OFFSET(&dblp->reginfo, namep);
+		} else
+			namep = R_ADDR(&dblp->reginfo, fnp->name_off);
+		memcpy(namep, newname, newlen);
+	} else {
+
+		/*
+		 * If more than 1 reference, just decrement the reference
+		 * and return.  Otherwise, free the name if one exists.
+		 */
+		DB_ASSERT(fnp->ref >= 1);
+		--fnp->ref;
+		if (fnp->ref == 0) {
+			if (fnp->name_off != INVALID_ROFF)
+				__db_shalloc_free(dblp->reginfo.addr,
+				    R_ADDR(&dblp->reginfo, fnp->name_off));
+			fnp->name_off = INVALID_ROFF;
+		}
+
+		/*
+		 * Remove from the process local table.  If this
+		 * operation is taking place during recovery, then
+		 * the logid was never added to the table, so do not remove it.
+		 */
+		if (!F_ISSET(dblp, DBLOG_RECOVER))
+			__log_rem_logid(dblp, dbp, fid);
+	}
+
+ret1:	R_UNLOCK(dbenv, &dblp->reginfo);
+	return (ret);
+}
+
+/*
+ * __log_file_lock -- lock a file for single access
+ *	This only works if logging is on.
+ *
+ * PUBLIC: int __log_file_lock __P((DB *));
+ */
+int
+__log_file_lock(dbp)
+	DB *dbp;
+{
+	DB_ENV *dbenv;
+	DB_LOG *dblp;
+	FNAME *fnp;
+	LOG *lp;
+	int ret;
+
+	dbenv = dbp->dbenv;
+	dblp = dbenv->lg_handle;
+	lp = dblp->reginfo.primary;
+
+	ret = 0;
+	R_LOCK(dbenv, &dblp->reginfo);
+
+	for (fnp = SH_TAILQ_FIRST(&lp->fq, __fname);
+	    fnp != NULL; fnp = SH_TAILQ_NEXT(fnp, q, __fname)) {
+		if (fnp->ref == 0)
+			continue;
+
+		if (!memcmp(dbp->fileid, fnp->ufid, DB_FILE_ID_LEN)) {
+			if (fnp->meta_pgno == 0) {
+				if (fnp->ref != 1)
+					goto err;
+
+				fnp->locked = 1;
+			} else {
+err:				__db_err(dbp->dbenv, "File is open");
+				ret = EINVAL;
+				goto done;
+			}
+
+		}
+	}
+done:	R_UNLOCK(dbenv, &dblp->reginfo);
+	return (ret);
+}