Update. cvs/libc-ud-970827

1997-08-10 19:17  Philip Blundell  <Philip.Blundell@pobox.com>

	* nss/nss_db/db-XXX.c: Include <db_185.h> not <db.h>.  Somebody
	should update this to use the new db API.
	* nss/nss_db/db-netgrp.c: Likewise.
	* nss/nss_db/db-alias.c: Likewise.
	* db2/Makefile: Makefile for db-2.x in glibc.

1997-08-27 21:20  Ulrich Drepper  <drepper@cygnus.com>

	* csu/Makefile (before-compile): New goal.  Make sure abi-tag.h
	is generated.
	[$(elf)=yes] (asm-CPPFLAGS): Make sure abi-tag.h file can be found.

	* Makeconfig [$(build-omitfp)=yes] (CFLAGS-.o): Add
	-D__USE_STRING_INLINES.
	* string/string.f: Move strnlen optimization after inclusion of
	<bits/string.h>.  Include <bits/string.h> only if __USE_STRING_INLINES
	is defined.
	* sysdeps/generic/memcpy.c: Undef memcpy to allow macro of this name
	in <bits/string.h>.
	* sysdeps/generic/memset.c: Likewise.
	* sysdeps/i386/string.h: i386 optimized string functions.
	* sysdeps/i386/i486string.h: i486+ optimized string functions.

	* Makefile (subdirs): Change db to db2.
	* shlib-versions: Bump libdb verion number to 3.
	* include/db.h: Include from db2 directory.
	* include/db_185.h: New file.
	* sysdeps/i386/Makefile [$(subdirs)=db2] (CPPFLAGS): Add macros
	to provide spinlock information for db2.
	* sysdeps/m68k/m68020/Makefile: New file.  Likewise.
	* sysdeps/sparc/Makefile: New file.  Likewise.
	* sysdeps/unix/sysv/linux/Makefile [$(subdirs)=db2] (CPPFLAGS):
	Add -DHAVE_LLSEEK.
	* db2/config.h: Hand-edited config file for db2 in glibc.
	* db2/compat.h: New file from db-2.3.4.
	* db2/db.h: Likewise.
	* db2/db_185.h: Likewise.
	* db2/db_int.h: Likewise.
	* db2/makedb.c: Likewise.
	* db2/btree/bt_close.c: Likewise.
	* db2/btree/bt_compare.c: Likewise.
	* db2/btree/bt_conv.c: Likewise.
	* db2/btree/bt_cursor.c: Likewise.
	* db2/btree/bt_delete.c: Likewise.
	* db2/btree/bt_open.c: Likewise.
	* db2/btree/bt_page.c: Likewise.
	* db2/btree/bt_put.c: Likewise.
	* db2/btree/bt_rec.c: Likewise.
	* db2/btree/bt_recno.c: Likewise.
	* db2/btree/btree_auto.c: Likewise.
	* db2/btree/bt_rsearch.c: Likewise.
	* db2/btree/bt_search.c: Likewise.
	* db2/btree/bt_split.c: Likewise.
	* db2/btree/bt_stat.c: Likewise.
	* db2/btree/btree.src: Likewise.
	* db2/common/db_appinit.c: Likewise.
	* db2/common/db_err.c: Likewise.
	* db2/common/db_byteorder.c: Likewise.
	* db2/common/db_apprec.c: Likewise.
	* db2/common/db_salloc.c: Likewise.
	* db2/common/db_log2.c: Likewise.
	* db2/common/db_region.c: Likewise.
	* db2/common/db_shash.c: Likewise.
	* db2/db/db.c: Likewise.
	* db2/db/db.src: Likewise.
	* db2/db/db_conv.c: Likewise.
	* db2/db/db_dispatch.c: Likewise.
	* db2/db/db_dup.c: Likewise.
	* db2/db/db_overflow.c: Likewise.
	* db2/db/db_pr.c: Likewise.
	* db2/db/db_rec.c: Likewise.
	* db2/db/db_ret.c: Likewise.
	* db2/db/db_thread.c: Likewise.
	* db2/db/db_auto.c: Likewise.
	* db2/db185/db185.c: Likewise.
	* db2/db185/db185_int.h: Likewise.
	* db2/dbm/dbm.c: Likewise.
	* db2/hash/hash.c: Likewise.
	* db2/hash/hash.src: Likewise.
	* db2/hash/hash_page.c: Likewise.
	* db2/hash/hash_conv.c: Likewise.
	* db2/hash/hash_debug.c: Likewise.
	* db2/hash/hash_stat.c: Likewise.
	* db2/hash/hash_rec.c: Likewise.
	* db2/hash/hash_dup.c: Likewise.
	* db2/hash/hash_func.c: Likewise.
	* db2/hash/hash_auto.c: Likewise.
	* db2/include/mp.h: Likewise.
	* db2/include/btree.h: Likewise.
	* db2/include/db.h.src: Likewise.
	* db2/include/db_int.h.src: Likewise.
	* db2/include/db_shash.h: Likewise.
	* db2/include/db_swap.h: Likewise.
	* db2/include/db_185.h.src: Likewise.
	* db2/include/txn.h: Likewise.
	* db2/include/db_am.h: Likewise.
	* db2/include/shqueue.h: Likewise.
	* db2/include/hash.h: Likewise.
	* db2/include/db_dispatch.h: Likewise.
	* db2/include/lock.h: Likewise.
	* db2/include/db_page.h: Likewise.
	* db2/include/log.h: Likewise.
	* db2/include/db_auto.h: Likewise.
	* db2/include/btree_auto.h: Likewise.
	* db2/include/hash_auto.h: Likewise.
	* db2/include/log_auto.h: Likewise.
	* db2/include/txn_auto.h: Likewise.
	* db2/include/db_ext.h: Likewise.
	* db2/include/btree_ext.h: Likewise.
	* db2/include/clib_ext.h: Likewise.
	* db2/include/common_ext.h: Likewise.
	* db2/include/hash_ext.h: Likewise.
	* db2/include/lock_ext.h: Likewise.
	* db2/include/log_ext.h: Likewise.
	* db2/include/mp_ext.h: Likewise.
	* db2/include/mutex_ext.h: Likewise.
	* db2/include/os_ext.h: Likewise.
	* db2/include/txn_ext.h: Likewise.
	* db2/include/cxx_int.h: Likewise.
	* db2/include/db_cxx.h: Likewise.
	* db2/include/queue.h: Likewise.
	* db2/lock/lock.c: Likewise.
	* db2/lock/lock_conflict.c: Likewise.
	* db2/lock/lock_util.c: Likewise.
	* db2/lock/lock_deadlock.c: Likewise.
	* db2/log/log.c: Likewise.
	* db2/log/log_get.c: Likewise.
	* db2/log/log.src: Likewise.
	* db2/log/log_compare.c: Likewise.
	* db2/log/log_put.c: Likewise.
	* db2/log/log_rec.c: Likewise.
	* db2/log/log_archive.c: Likewise.
	* db2/log/log_register.c: Likewise.
	* db2/log/log_auto.c: Likewise.
	* db2/log/log_findckp.c: Likewise.
	* db2/mp/mp_bh.c: Likewise.
	* db2/mp/mp_fget.c: Likewise.
	* db2/mp/mp_fopen.c: Likewise.
	* db2/mp/mp_fput.c: Likewise.
	* db2/mp/mp_fset.c: Likewise.
	* db2/mp/mp_open.c: Likewise.
	* db2/mp/mp_region.c: Likewise.
	* db2/mp/mp_pr.c: Likewise.
	* db2/mp/mp_sync.c: Likewise.
	* db2/mutex/68020.gcc: Likewise.
	* db2/mutex/mutex.c: Likewise.
	* db2/mutex/README: Likewise.
	* db2/mutex/x86.gcc: Likewise.
	* db2/mutex/sparc.gcc: Likewise.
	* db2/mutex/uts4.cc.s: Likewise.
	* db2/mutex/alpha.dec: Likewise.
	* db2/mutex/alpha.gcc: Likewise.
	* db2/mutex/parisc.gcc: Likewise.
	* db2/mutex/parisc.hp: Likewise.
	* db2/os/db_os_abs.c: Likewise.
	* db2/os/db_os_dir.c: Likewise.
	* db2/os/db_os_fid.c: Likewise.
	* db2/os/db_os_lseek.c: Likewise.
	* db2/os/db_os_mmap.c: Likewise.
	* db2/os/db_os_open.c: Likewise.
	* db2/os/db_os_rw.c: Likewise.
	* db2/os/db_os_sleep.c: Likewise.
	* db2/os/db_os_stat.c: Likewise.
	* db2/os/db_os_unlink.c: Likewise.
	* db2/txn/txn.c: Likewise.
	* db2/txn/txn.src: Likewise.
	* db2/txn/txn_rec.c: Likewise.
	* db2/txn/txn_auto.c: Likewise.
	* db2/clib/getlong.c: Likewise.
	* db2/progs/db_archive/db_archive.c: Likewise.
	* db2/progs/db_checkpoint/db_checkpoint.c: Likewise.
	* db2/progs/db_deadlock/db_deadlock.c: Likewise.
	* db2/progs/db_dump/db_dump.c: Likewise.
	* db2/progs/db_dump185/db_dump185.c: Likewise.
	* db2/progs/db_load/db_load.c: Likewise.
	* db2/progs/db_printlog/db_printlog.c: Likewise.
	* db2/progs/db_recover/db_recover.c: Likewise.
	* db2/progs/db_stat/db_stat.c: Likewise.

	* libio/stdio.h [__cplusplus] (__STDIO_INLINE): Define as inline.

	* po/de.po, po/sv.po: Update from 2.0.5 translations.

	* sysdeps/unix/sysv/linux/netinet/tcp.h: Pretty print.

	* sunrpc/rpc/xdr.h (XDR): Don't define argument of x_destroy callback
	as const.
	* sunrpc/xdr_mem.c (xdrmem_destroy): Don't define argument as const.
	* sunrpx/xdr_rec.c (xdrrec_destroy): Likewise.
	* sunrpx/xdr_stdio.c (xdrstdio_destroy): Likewise.

1997-08-27 18:47  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/if_index.c: Include <errno.h>.
	Reported by Benjamin Kosnik <bkoz@cygnus.com>.

1997-08-27 02:27  Roland McGrath  <roland@baalperazim.frob.com>

	* abi-tags: New file.
	* csu/Makefile (distribute): Remove abi-tag.h.
	($(objpfx)abi-tag.h): New target.
	* Makefile (distribute): Add abi-tags.
	* sysdeps/unix/sysv/linux/abi-tag.h: File removed.
	* sysdeps/mach/hurd/abi-tag.h: File removed.
	* sysdeps/stub/abi-tag.h: File removed.

1997-08-25  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/unix/make-syscalls.sh: Change output so that it
	generates compilation rules only for the currently selected object
	suffixes.

1997-08-25  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/dl-machine.h (RTLD_START): Switch back to previous
	section to avoid confusing the compiler.
	* sysdeps/alpha/dl-machine.h (RTLD_START): Likewise.
	* sysdeps/i386/dl-machine.h (RTLD_START): Likewise.
	* sysdeps/mips/dl-machine.h (RTLD_START): Likewise.
	* sysdeps/mips/mips64/dl-machine.h (RTLD_START): Likewise.
	* sysdeps/sparc/sparc32/dl-machine.h (RTLD_START): Likewise.

	* sysdeps/m68k/dl-machine.h (elf_machine_load_address): Use a GOT
	relocation instead of a constant to avoid text relocation.
	(ELF_MACHINE_BEFORE_RTLD_RELOC): Removed.
	(RTLD_START): Declare global labels as functions and add size
	directive.

1997-08-25 17:01  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/i386/bits/select.h: Correct assembler versions to work even
	for descriptors >= 32.

	* stdlib/alloca.h: Don't define alloca to __alloca since if gcc
	is used __alloca is not defined to __builtin_alloca and so might
	not be available.
	Reported by Uwe Ohse <uwe@ohse.de>.

	* sysdeps/unix/sysv/linux/sys/sysmacros.h: Define macros in a special
	way if gcc is not used and so dev_t is an array.
	Reported by Uwe Ohse <uwe@ohse.de>.

1997-08-23  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* manual/libc.texinfo: Reorder chapters to match logical order.

1997-08-25 12:22  Ulrich Drepper  <drepper@cygnus.com>

	* sunrpc/rpc/xdr.h: Change name of parameters in prototypes of
	xdr_reference, xdrmem_create, and xdrstdio_create because of clash
	with g++ internal symbols.
	Patch by Sudish Joseph <sj@eng.mindspring.net>.

	* elf/dl-deps.c: Implement handling of DT_FILTER.

1 files changed, 565 insertions, 0 deletions

diff --git a/db2/common/db_region.c b/db2/common/db_region.c
new file mode 100644
index 0000000000..51f8f4465c
--- /dev/null
+++ b/db2/common/db_region.c
@@ -0,0 +1,565 @@
+/*-
+ * See the file LICENSE for redistribution information.
+ *
+ * Copyright (c) 1996, 1997
+ *	Sleepycat Software.  All rights reserved.
+ */
+/*
+ * Copyright (c) 1995, 1996
+ *	The President and Fellows of Harvard University.  All rights reserved.
+ *
+ * This code is derived from software contributed to Harvard by
+ * Margo Seltzer.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#ifndef lint
+static const char sccsid[] = "@(#)db_region.c	10.12 (Sleepycat) 7/26/97";
+#endif /* not lint */
+
+#ifndef NO_SYSTEM_INCLUDES
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#endif
+
+#include "db_int.h"
+#include "common_ext.h"
+
+static int __db_rmap __P((DB_ENV *, int, size_t, void *));
+
+/*
+ * __db_rcreate --
+ *
+ * Common interface for creating a shared region.  Handles synchronization
+ * across multiple processes.
+ *
+ * The dbenv contains the environment for this process, including naming
+ * information.  The path argument represents the parameters passed to
+ * the open routines and may be either a file or a directory.  If it is
+ * a directory, it must exist.  If it is a file, then the file parameter
+ * must be NULL, otherwise, file is the name to be created inside the
+ * directory path.
+ *
+ * The function returns a pointer to the shared region that has been mapped
+ * into memory, NULL on error.
+ *
+ * PUBLIC: int __db_rcreate __P((DB_ENV *, APPNAME,
+ * PUBLIC:    const char *, const char *, int, size_t, int *, void *));
+ */
+int
+__db_rcreate(dbenv, appname, path, file, mode, size, fdp, retp)
+	DB_ENV *dbenv;
+	APPNAME appname;
+	const char *path, *file;
+	int mode, *fdp;
+	size_t size;
+	void *retp;
+{
+	RLAYOUT *rp;
+	int fd, ret;
+	char *name;
+
+	fd = -1;
+	rp = NULL;
+
+	/*
+	 * Get the filename -- note, if it's a temporary file, it will
+	 * be created by the underlying temporary file creation code,
+	 * so we have to check the file descriptor to be sure it's an
+	 * error.
+	 */
+	if ((ret = __db_appname(dbenv, appname, path, file, &fd, &name)) != 0)
+		return (ret);
+
+	/*
+	 * Now open the file. We need to make sure that multiple processes
+	 * that attempt to create the region at the same time are properly
+	 * ordered, so we open it O_EXCL and O_CREAT so two simultaneous
+	 * attempts to create the region will return failure in one of the
+	 * attempts.
+	 */
+	if (fd == -1 && (ret = __db_fdopen(name,
+	    DB_CREATE | DB_EXCL, DB_CREATE | DB_EXCL, mode, &fd)) != 0) {
+		if (ret != EEXIST)
+			__db_err(dbenv,
+			    "region create: %s: %s", name, strerror(ret));
+		goto err;
+	}
+	*fdp = fd;
+
+	/* Grow the region to the correct size. */
+	if ((ret = __db_rgrow(dbenv, fd, size)) != 0)
+		goto err;
+
+	/* Map the region in. */
+	if ((ret = __db_rmap(dbenv, fd, size, &rp)) != 0)
+		goto err;
+
+	/*
+	 * Initialize the common information.
+	 *
+	 * !!!
+	 * We have to order the region creates so that two processes don't try
+	 * to simultaneously create the region and so that processes that are
+	 * joining the region never see inconsistent data.  We'd like to play
+	 * file permissions games, but we can't because WNT filesystems won't
+	 * open a file mode 0.
+	 *
+	 * So, the process that's creating the region always acquires the lock
+	 * before the setting the version number.  Any process joining always
+	 * checks the version number before attempting to acquire the lock.
+	 *
+	 * We have to check the version number first, because if the version
+	 * number has not been written, it's possible that the mutex has not
+	 * been initialized in which case an attempt to get it could lead to
+	 * random behavior.  If the version number isn't there (the file size
+	 * is too small) or it's 0, we know that the region is being created.
+	 */
+	(void)__db_mutex_init(&rp->lock, MUTEX_LOCK_OFFSET(rp, &rp->lock));
+	(void)__db_mutex_lock(&rp->lock,
+	    fd, dbenv == NULL ? NULL : dbenv->db_yield);
+
+	rp->refcnt = 1;
+	rp->size = size;
+	rp->flags = 0;
+	db_version(&rp->majver, &rp->minver, &rp->patch);
+
+	if (name != NULL)
+		FREES(name);
+
+	*(void **)retp = rp;
+	return (0);
+
+err:	if (fd != -1) {
+		if (rp != NULL)
+			(void)__db_munmap(rp, rp->size);
+		(void)__db_unlink(name);
+		(void)__db_close(fd);
+	}
+	if (name != NULL)
+		FREES(name);
+	return (ret);
+}
+
+/*
+ * __db_ropen --
+ *	Construct the name of a file, open it and map it in.
+ *
+ * PUBLIC: int __db_ropen __P((DB_ENV *,
+ * PUBLIC:    APPNAME, const char *, const char *, int, int *, void *));
+ */
+int
+__db_ropen(dbenv, appname, path, file, flags, fdp, retp)
+	DB_ENV *dbenv;
+	APPNAME appname;
+	const char *path, *file;
+	int flags, *fdp;
+	void *retp;
+{
+	RLAYOUT *rp;
+	off_t size1, size2;
+	int fd, ret;
+	char *name;
+
+	fd = -1;
+	rp = NULL;
+
+	/* Get the filename. */
+	if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
+		return (ret);
+
+	/* Open the file. */
+	if ((ret = __db_fdopen(name, flags, DB_MUTEXDEBUG, 0, &fd)) != 0) {
+		__db_err(dbenv, "region open: %s: %s", name, strerror(ret));
+		goto err2;
+	}
+
+	*fdp = fd;
+
+	/*
+	 * Map the file in.  We have to do things in a strange order so that
+	 * we don't get into a situation where the file was just created and
+	 * isn't yet initialized.  See the comment in __db_rcreate() above.
+	 *
+	 * XXX
+	 * We'd like to test to see if the file is too big to mmap.  Since we
+	 * don't know what size or type off_t's or size_t's are, or the largest
+	 * unsigned integral type is, or what random insanity the local C
+	 * compiler will perpetrate, doing the comparison in a portable way is
+	 * flatly impossible.  Hope that mmap fails if the file is too large.
+	 *
+	 */
+	if ((ret = __db_stat(dbenv, name, fd, &size1, NULL)) != 0)
+		goto err2;
+
+	/* Check to make sure the first block has been written. */
+	if ((size_t) size1 < sizeof(RLAYOUT)) {
+		ret = EAGAIN;
+		goto err2;
+	}
+
+	/* Map in whatever is there. */
+	if ((ret = __db_rmap(dbenv, fd, size1, &rp)) != 0)
+		goto err2;
+
+	/*
+	 * Check to make sure the region has been initialized.  We can't just
+	 * grab the lock because the lock may not have been initialized yet.
+	 */
+	if (rp->majver == 0) {
+		ret = EAGAIN;
+		goto err2;
+	}
+
+	/* Get the region lock. */
+	if (!LF_ISSET(DB_MUTEXDEBUG))
+		(void)__db_mutex_lock(&rp->lock,
+		    fd, dbenv == NULL ? NULL : dbenv->db_yield);
+
+	/*
+	 * The file may have been half-written if we were descheduled between
+	 * getting the size of the file and checking the major version.  Check
+	 * to make sure we got the entire file.
+	 */
+	if ((ret = __db_stat(dbenv, name, fd, &size2, NULL)) != 0)
+		goto err1;
+	if (size1 != size2) {
+		ret = EAGAIN;
+		goto err1;
+	}
+
+	/* The file may have just been deleted. */
+	if (F_ISSET(rp, DB_R_DELETED)) {
+		ret = EAGAIN;
+		goto err1;
+	}
+
+	/* Increment the reference count. */
+	++rp->refcnt;
+
+	/* Release the lock. */
+	if (!LF_ISSET(DB_MUTEXDEBUG))
+		(void)__db_mutex_unlock(&rp->lock, fd);
+
+	FREES(name);
+
+	*(void **)retp = rp;
+	return (0);
+
+err1:	if (!LF_ISSET(DB_MUTEXDEBUG))
+		(void)__db_mutex_unlock(&rp->lock, fd);
+err2:	if (rp != NULL)
+		(void)__db_munmap(rp, rp->size);
+	if (fd != -1)
+		(void)__db_close(fd);
+	FREES(name);
+	return (ret);
+}
+
+/*
+ * __db_rclose --
+ *	Close a shared memory region.
+ *
+ * PUBLIC: int __db_rclose __P((DB_ENV *, int, void *));
+ */
+int
+__db_rclose(dbenv, fd, ptr)
+	DB_ENV *dbenv;
+	int fd;
+	void *ptr;
+{
+	RLAYOUT *rp;
+	int ret, t_ret;
+	const char *fail;
+
+	rp = ptr;
+	fail = NULL;
+
+	/* Get the lock. */
+	if ((ret = __db_mutex_lock(&rp->lock,
+	    fd, dbenv == NULL ? NULL : dbenv->db_yield)) != 0) {
+		fail = "lock get";
+		goto err;
+	}
+
+	/* Decrement the reference count. */
+	--rp->refcnt;
+
+	/* Release the lock. */
+	if ((t_ret = __db_mutex_unlock(&rp->lock, fd)) != 0 && fail == NULL) {
+		ret = t_ret;
+		fail = "lock release";
+	}
+
+	/* Discard the region. */
+	if ((t_ret = __db_munmap(ptr, rp->size)) != 0 && fail == NULL) {
+		ret = t_ret;
+		fail = "munmap";
+	}
+
+	if ((t_ret = __db_close(fd)) != 0 && fail == NULL) {
+		ret = t_ret;
+		fail = "close";
+	}
+
+	if (fail == NULL)
+		return (0);
+
+err:	__db_err(dbenv, "region detach: %s: %s", fail, strerror(ret));
+	return (ret);
+}
+
+/*
+ * __db_runlink --
+ *	Remove a shared memory region.
+ *
+ * PUBLIC: int __db_runlink __P((DB_ENV *,
+ * PUBLIC:    APPNAME, const char *, const char *, int));
+ */
+int
+__db_runlink(dbenv, appname, path, file, force)
+	DB_ENV *dbenv;
+	APPNAME appname;
+	const char *path, *file;
+	int force;
+{
+	RLAYOUT *rp;
+	int cnt, fd, ret, t_ret;
+	char *name;
+
+	rp = NULL;
+
+	/* Get the filename. */
+	if ((ret = __db_appname(dbenv, appname, path, file, NULL, &name)) != 0)
+		return (ret);
+
+	/* If the file doesn't exist, we're done. */
+	if (__db_exists(name, NULL))
+		return (0);		/* XXX: ENOENT? */
+
+	/*
+	 * If we're called with a force flag, try and unlink the file.  This
+	 * may not succeed if the file is currently open, but there's nothing
+	 * we can do about that.  There is a race condition between the check
+	 * for existence above and the actual unlink.  If someone else snuck
+	 * in and removed it before we do the remove, then we might get an
+	 * ENOENT error.  If we get the ENOENT, we treat it as success, just
+	 * as we do above.
+	 */
+	if (force) {
+		if ((ret = __db_unlink(name)) != 0 && ret != ENOENT)
+			goto err1;
+		FREES(name);
+		return (0);
+	}
+
+	/* Open and lock the region. */
+	if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
+		goto err1;
+	(void)__db_mutex_lock(&rp->lock,
+	    fd, dbenv == NULL ? NULL : dbenv->db_yield);
+
+	/* If the region is currently being deleted, fail. */
+	if (F_ISSET(rp, DB_R_DELETED)) {
+		ret = ENOENT;		/* XXX: ENOENT? */
+		goto err2;
+	}
+
+	/* If the region is currently in use by someone else, fail. */
+	if (rp->refcnt > 1) {
+		ret = EBUSY;
+		goto err2;
+	}
+
+	/* Set the delete flag. */
+	F_SET(rp, DB_R_DELETED);
+
+	/* Release the lock and close the region. */
+	(void)__db_mutex_unlock(&rp->lock, fd);
+	if ((t_ret = __db_rclose(dbenv, fd, rp)) != 0 && ret == 0)
+		goto err1;
+
+	/*
+	 * Unlink the region.  There's a race here -- other threads or
+	 * processes might be opening the region while we're trying to
+	 * remove it.  They'll fail, because we've set the DELETED flag,
+	 * but they could still stop us from succeeding in the unlink.
+	 */
+	for (cnt = 5; cnt > 0; --cnt) {
+		if ((ret = __db_unlink(name)) == 0)
+			break;
+		(void)__db_sleep(0, 250000);
+	}
+	if (ret == 0) {
+		FREES(name);
+		return (0);
+	}
+
+	/* Not a clue.  Try to clear the DB_R_DELETED flag. */
+	if ((ret = __db_ropen(dbenv, appname, path, file, 0, &fd, &rp)) != 0)
+		goto err1;
+	(void)__db_mutex_lock(&rp->lock,
+	    fd, dbenv == NULL ? NULL : dbenv->db_yield);
+	F_CLR(rp, DB_R_DELETED);
+	/* FALLTHROUGH */
+
+err2:	(void)__db_mutex_unlock(&rp->lock, fd);
+	(void)__db_rclose(dbenv, fd, rp);
+err1:	__db_err(dbenv, "region unlink: %s: %s", name, strerror(ret));
+	FREES(name);
+	return (ret);
+}
+
+/*
+ * DB creates all regions on 4K boundaries so that we don't make the
+ * underlying VM unhappy.
+ */
+#define	__DB_VMPAGESIZE	(4 * 1024)
+
+/*
+ * __db_rgrow --
+ *	Extend a region by a specified amount.
+ *
+ * PUBLIC: int __db_rgrow __P((DB_ENV *, int, size_t));
+ */
+int
+__db_rgrow(dbenv, fd, incr)
+	DB_ENV *dbenv;
+	int fd;
+	size_t incr;
+{
+#ifdef MMAP_INIT_NEEDED
+	size_t i;
+#endif
+	ssize_t nw;
+	int ret;
+	char buf[__DB_VMPAGESIZE];
+
+	/* Seek to the end of the region. */
+	if ((ret = __db_lseek(fd, 0, 0, 0, SEEK_END)) != 0)
+		goto err;
+
+	/* Write nuls to the new bytes. */
+	memset(buf, 0, sizeof(buf));
+
+	/*
+	 * Historically, some systems required that all of the bytes of the
+	 * region be written before you could mmap it and access it randomly.
+	 */
+#ifdef MMAP_INIT_NEEDED
+	/* Extend the region by writing each new page. */
+	for (i = 0; i < incr; i += __DB_VMPAGESIZE) {
+		if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
+			goto err;
+		if (nw != sizeof(buf))
+			goto eio;
+	}
+#else
+	/*
+	 * Extend the region by writing the last page.
+	 *
+	 * Round off the increment to the next page boundary.
+	 */
+	incr += __DB_VMPAGESIZE - 1;
+	incr -= incr % __DB_VMPAGESIZE;
+
+	/* Write the last page, not the page after the last. */
+	if ((ret = __db_lseek(fd, 0, 0, incr - __DB_VMPAGESIZE, SEEK_CUR)) != 0)
+		goto err;
+	if ((ret = __db_write(fd, buf, sizeof(buf), &nw)) != 0)
+		goto err;
+	if (nw != sizeof(buf))
+		goto eio;
+#endif
+	return (0);
+
+eio:	ret = EIO;
+err:	__db_err(dbenv, "region grow: %s", strerror(ret));
+	return (ret);
+}
+
+/*
+ * __db_rremap --
+ *	Unmap the old region and map in a new region of a new size.  If
+ *	either call fails, returns NULL, else returns the address of the
+ *	new region.
+ *
+ * PUBLIC: int __db_rremap __P((DB_ENV *, void *, size_t, size_t, int, void *));
+ */
+int
+__db_rremap(dbenv, ptr, oldsize, newsize, fd, retp)
+	DB_ENV *dbenv;
+	void *ptr, *retp;
+	size_t oldsize, newsize;
+	int fd;
+{
+	int ret;
+
+	if ((ret = __db_munmap(ptr, oldsize)) != 0) {
+		__db_err(dbenv, "region remap: munmap: %s", strerror(ret));
+		return (ret);
+	}
+
+	return (__db_rmap(dbenv, fd, newsize, retp));
+}
+
+/*
+ * __db_rmap --
+ *	Attach to a shared memory region.
+ */
+static int
+__db_rmap(dbenv, fd, size, retp)
+	DB_ENV *dbenv;
+	int fd;
+	size_t size;
+	void *retp;
+{
+	RLAYOUT *rp;
+	int ret;
+
+	if ((ret = __db_mmap(fd, size, 0, 0, &rp)) != 0) {
+		__db_err(dbenv, "region map: mmap %s", strerror(ret));
+		return (ret);
+	}
+	if (rp->size < size)
+		rp->size = size;
+
+	*(void **)retp = rp;
+	return (0);
+}