From: Kurt Spanier <ksp@openldap.org>
Date: Fri, 12 Feb 1999 12:13:03 +0000 (+0000)
Subject: Update of back-bdb2 to KDZ's new entry lock schema.
X-Git-Tag: OPENLDAP_SLAPD_BACK_LDAP~589
X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=6e63b58a3e3f8421d6d988a3a57749a0bece83d4;p=openldap

Update of back-bdb2 to KDZ's new entry lock schema.
Fix of a back-bdb2 --> back-ldbm leakage (==> new bdb2-specific DB file suffix).
---

diff --git a/servers/slapd/back-bdb2/add.c b/servers/slapd/back-bdb2/add.c
index f7d3274e1e..50125c6ab7 100644
--- a/servers/slapd/back-bdb2/add.c
+++ b/servers/slapd/back-bdb2/add.c
@@ -23,7 +23,7 @@ bdb2i_back_add_internal(
 	char		*pdn;
 	Entry		*p = NULL;
 	int			rootlock = 0;
-	int			rc = -1; 
+	int			rc; 
 
 	Debug(LDAP_DEBUG_ARGS, "==> bdb2i_back_add: %s\n", e->e_dn, 0, 0);
 
@@ -121,40 +121,19 @@ bdb2i_back_add_internal(
 		ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
 	}
 
-	/* acquire required reader/writer lock */
-	if (entry_rdwr_lock(e, 1)) {
-		if( p != NULL) {
-			/* free parent and writer lock */
-			bdb2i_cache_return_entry_w( &li->li_cache, p ); 
-		}
-
-		if ( rootlock ) {
-			/* release root lock */
-			ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
-		}
-
-		Debug( LDAP_DEBUG_ANY, "add: could not lock entry\n",
-			0, 0, 0 );
-
-		entry_free(e);
-
-		send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
-		return( -1 );
-	}
-
 	e->e_id = bdb2i_next_id( be );
 
 	/*
-	 * Try to add the entry to the cache, assign it a new dnid
-	 * This should only fail if the entry already exists.
+	 * Try to add the entry to the cache, assign it a new dnid.
 	 */
+	rc = bdb2i_cache_add_entry_rw( &li->li_cache, e, CACHE_WRITE_LOCK );
 
-	if ( bdb2i_cache_add_entry_lock( &li->li_cache, e, ENTRY_STATE_CREATING )
-								!= 0 ) {
+	if ( rc != 0 ) {
 		if( p != NULL) {
 			/* free parent and writer lock */
 			bdb2i_cache_return_entry_w( &li->li_cache, p ); 
 		}
+
 		if ( rootlock ) {
 			/* release root lock */
 			ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
@@ -162,15 +141,24 @@ bdb2i_back_add_internal(
 
 		Debug( LDAP_DEBUG_ANY, "cache_add_entry_lock failed\n", 0, 0,
 		    0 );
+
+		/* return the id */
 		bdb2i_next_id_return( be, e->e_id );
                 
-		entry_rdwr_unlock(e, 1);
+		/* free the entry */
 		entry_free( e );
 
-		send_ldap_result( conn, op, LDAP_ALREADY_EXISTS, "", "" );
+		if(rc > 0) {
+			send_ldap_result( conn, op, LDAP_ALREADY_EXISTS, "", "" );
+		} else {
+			send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR, "", "" );
+		}
+
 		return( -1 );
 	}
 
+	rc = -1;
+
 	/*
 	 * add it to the id2children index for the parent
 	 */
@@ -231,8 +219,6 @@ return_results:;
 		ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
 	}
 
-	bdb2i_cache_set_state( &li->li_cache, e, 0 );
-
 	/* free entry and writer lock */
 	bdb2i_cache_return_entry_w( &li->li_cache, e ); 
 
diff --git a/servers/slapd/back-bdb2/back-bdb2.h b/servers/slapd/back-bdb2/back-bdb2.h
index 715dfd6485..3179819fb2 100644
--- a/servers/slapd/back-bdb2/back-bdb2.h
+++ b/servers/slapd/back-bdb2/back-bdb2.h
@@ -20,7 +20,7 @@ LDAP_BEGIN_DECL
 
 #define SUBLEN			3
 
-#define BDB2_SUFFIX     ".dbb"
+#define BDB2_SUFFIX     ".bdb2"
 
 
 /*
@@ -82,6 +82,9 @@ struct cache {
 	ldap_pvt_thread_mutex_t	c_mutex;
 };
 
+#define CACHE_READ_LOCK		1
+#define CACHE_WRITE_LOCK	2
+
 /* for the cache of open index files (re-used for txn) */
 struct dbcache {
 	int			dbc_refcnt;
diff --git a/servers/slapd/back-bdb2/cache.c b/servers/slapd/back-bdb2/cache.c
index 2917f52e56..9581ef5194 100644
--- a/servers/slapd/back-bdb2/cache.c
+++ b/servers/slapd/back-bdb2/cache.c
@@ -12,107 +12,203 @@
 
 #include "back-bdb2.h"
 
+/* LDBM backend specific entry info -- visible only to the cache */
+struct ldbm_entry_info {
+	ldap_pvt_thread_rdwr_t	lei_rdwr;	/* reader/writer lock */
+
+	/*
+	 * remaining fields require backend cache lock to access
+	 * These items are specific to the LDBM backend and should
+	 * be hidden.
+	 */
+	int		lei_state;	/* for the cache */
+#define CACHE_ENTRY_UNDEFINED	0
+#define CACHE_ENTRY_CREATING	1
+#define CACHE_ENTRY_READY		2
+#define CACHE_ENTRY_DELETED		3
+
+	int		lei_refcnt;	/* # threads ref'ing this entry */
+	struct entry	*lei_lrunext;	/* for cache lru list */
+	struct entry	*lei_lruprev;
+};
+#define LEI(e)	((struct ldbm_entry_info *) ((e)->e_private))
+
 static int	cache_delete_entry_internal(struct cache *cache, Entry *e);
 #ifdef LDAP_DEBUG
 static void	lru_print(struct cache *cache);
 #endif
 
-void
-bdb2i_cache_set_state( struct cache *cache, Entry *e, int state )
+static int
+cache_entry_rdwr_lock(Entry *e, int rw)
 {
-	/* set cache mutex */
-	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
+	Debug( LDAP_DEBUG_ARGS, "entry_rdwr_%slock: ID: %ld\n",
+		rw ? "w" : "r", e->e_id, 0);
 
-	e->e_state = state;
+	if (rw)
+		return ldap_pvt_thread_rdwr_wlock(&LEI(e)->lei_rdwr);
+	else
+		return ldap_pvt_thread_rdwr_rlock(&LEI(e)->lei_rdwr);
+}
 
-	/* free cache mutex */
-	ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+static int
+cache_entry_rdwr_trylock(Entry *e, int rw)
+{
+	Debug( LDAP_DEBUG_ARGS, "entry_rdwr_%strylock: ID: %ld\n",
+		rw ? "w" : "r", e->e_id, 0);
+
+	if (rw)
+		return ldap_pvt_thread_rdwr_wtrylock(&LEI(e)->lei_rdwr);
+	else
+		return ldap_pvt_thread_rdwr_rtrylock(&LEI(e)->lei_rdwr);
 }
 
-#ifdef not_used
-static void
-cache_return_entry( struct cache *cache, Entry *e )
+static int
+cache_entry_rdwr_unlock(Entry *e, int rw)
 {
-	/* set cache mutex */
-	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
+	Debug( LDAP_DEBUG_ARGS, "entry_rdwr_%sunlock: ID: %ld\n",
+		rw ? "w" : "r", e->e_id, 0);
 
-	if ( --e->e_refcnt == 0 && e->e_state == ENTRY_STATE_DELETED ) {
-		entry_free( e );
-	}
+	if (rw)
+		return ldap_pvt_thread_rdwr_wunlock(&LEI(e)->lei_rdwr);
+	else
+		return ldap_pvt_thread_rdwr_runlock(&LEI(e)->lei_rdwr);
+}
 
-	/* free cache mutex */
-	ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+static int
+cache_entry_rdwr_init(Entry *e)
+{
+	return ldap_pvt_thread_rdwr_init( &LEI(e)->lei_rdwr );
 }
-#endif
 
-static void
-cache_return_entry_rw( struct cache *cache, Entry *e, int rw )
+static int
+cache_entry_rdwr_destroy(Entry *e)
 {
-	Debug( LDAP_DEBUG_TRACE, "====> cache_return_entry_%s\n",
-		rw ? "w" : "r", 0, 0);
+	return ldap_pvt_thread_rdwr_destroy( &LEI(e)->lei_rdwr );
+}
 
-	/* set cache mutex */
-	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
+static int
+cache_entry_private_init( Entry*e )
+{
+	struct ldbm_entry_info *lei;
 
-	entry_rdwr_unlock(e, rw);
+#ifdef LDAP_DEBUG
+	assert( e->e_private == NULL );
+#endif
 
-	if ( --e->e_refcnt == 0 && e->e_state == ENTRY_STATE_DELETED ) {
-		entry_free( e );
+	if( e->e_private != NULL ) {
+		/* this should never happen */
+		return 1;
 	}
 
-	/* free cache mutex */
-	ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+	e->e_private = ch_calloc(1, sizeof(struct ldbm_entry_info));
+
+	if( cache_entry_rdwr_init( e ) != 0 ) {
+		free( LEI(e) );
+		e->e_private = NULL;
+		return 1;
+	} 
+
+	return 0;
 }
 
-void
-bdb2i_cache_return_entry_r( struct cache *cache, Entry *e )
+static int
+cache_entry_private_destroy( Entry*e )
 {
-	cache_return_entry_rw(cache, e, 0);
+	struct ldbm_entry_info *lei;
+
+#ifdef LDAP_DEBUG
+	assert( e->e_private );
+#endif
+
+	cache_entry_rdwr_destroy( e );
+
+	free( e->e_private );
+	e->e_private = NULL;
+	return 0;
 }
 
 void
-bdb2i_cache_return_entry_w( struct cache *cache, Entry *e )
+bdb2i_cache_return_entry_rw( struct cache *cache, Entry *e, int rw )
 {
-	cache_return_entry_rw(cache, e, 1);
-}
+	/* set cache mutex */
+	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
+
+#ifdef LDAP_DEBUG
+	assert( e->e_private );
+#endif
+
+	cache_entry_rdwr_unlock(e, rw);
+
+	LEI(e)->lei_refcnt--;
+
+	if ( LEI(e)->lei_state == CACHE_ENTRY_CREATING ) {
+		Debug( LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_return_entry_%s( %ld ): created (%d)\n",
+			rw ? "w" : "r", e->e_id, LEI(e)->lei_refcnt );
+
+		LEI(e)->lei_state = CACHE_ENTRY_READY;
+
+	} else if ( LEI(e)->lei_state == CACHE_ENTRY_DELETED ) {
+		if( LEI(e)->lei_refcnt > 0 ) {
+			Debug( LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_return_entry_%s( %ld ): delete pending (%d)\n",
+				rw ? "w" : "r", e->e_id, LEI(e)->lei_refcnt );
 
+		} else {
+			Debug( LDAP_DEBUG_TRACE,
+				"====> bdb2i_cache_return_entry_%s( %ld ): deleted (%d)\n",
+				rw ? "w" : "r", e->e_id, LEI(e)->lei_refcnt );
+
+			cache_entry_private_destroy( e );
+			entry_free( e );
+		}
+
+	} else {
+		Debug( LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_return_entry_%s( %ld ): returned (%d)\n",
+			rw ? "w" : "r", e->e_id, LEI(e)->lei_refcnt);
+	}
+
+	/* free cache mutex */
+	ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+}
 
 #define LRU_DELETE( cache, e ) { \
-	if ( e->e_lruprev != NULL ) { \
-		e->e_lruprev->e_lrunext = e->e_lrunext; \
+	if ( LEI(e)->lei_lruprev != NULL ) { \
+		LEI(LEI(e)->lei_lruprev)->lei_lrunext = LEI(e)->lei_lrunext; \
 	} else { \
-		cache->c_lruhead = e->e_lrunext; \
+		cache->c_lruhead = LEI(e)->lei_lrunext; \
 	} \
-	if ( e->e_lrunext != NULL ) { \
-		e->e_lrunext->e_lruprev = e->e_lruprev; \
+	if ( LEI(e)->lei_lrunext != NULL ) { \
+		LEI(LEI(e)->lei_lrunext)->lei_lruprev = LEI(e)->lei_lruprev; \
 	} else { \
-		cache->c_lrutail = e->e_lruprev; \
+		cache->c_lrutail = LEI(e)->lei_lruprev; \
 	} \
 }
 
 #define LRU_ADD( cache, e ) { \
-	e->e_lrunext = cache->c_lruhead; \
-	if ( e->e_lrunext != NULL ) { \
-		e->e_lrunext->e_lruprev = e; \
+	LEI(e)->lei_lrunext = cache->c_lruhead; \
+	if ( LEI(e)->lei_lrunext != NULL ) { \
+		LEI(LEI(e)->lei_lrunext)->lei_lruprev = e; \
 	} \
 	cache->c_lruhead = e; \
-	e->e_lruprev = NULL; \
+	LEI(e)->lei_lruprev = NULL; \
 	if ( cache->c_lrutail == NULL ) { \
 		cache->c_lrutail = e; \
 	} \
 }
 
 /*
- * cache_create_entry_lock - create an entry in the cache, and lock it.
+ * bdb2i_cache_add_entry_rw - create and lock an entry in the cache
  * returns:	0	entry has been created and locked
  *		1	entry already existed
  *		-1	something bad happened
  */
 int
-bdb2i_cache_add_entry_lock(
+bdb2i_cache_add_entry_rw(
     struct cache	*cache,
     Entry		*e,
-    int			state
+	int		rw
 )
 {
 	int	i, rc;
@@ -121,12 +217,25 @@ bdb2i_cache_add_entry_lock(
 	/* set cache mutex */
 	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
 
+#ifdef LDAP_DEBUG
+	assert( e->e_private == NULL );
+#endif
+
+	if( cache_entry_private_init(e) != 0 ) {
+		Debug( LDAP_DEBUG_ANY,
+		"====> bdb2i_cache_add_entry( %ld ): \"%s\": private init failed!\n",
+		    e->e_id, e->e_dn, 0 );
+		return( -1 );
+	}
+
 	if ( avl_insert( &cache->c_dntree, (caddr_t) e,
 		entry_dn_cmp, avl_dup_error ) != 0 )
 	{
 		Debug( LDAP_DEBUG_TRACE,
-			"====> cache_add_entry lock: entry %20s id %lu already in dn cache\n",
-		    e->e_dn, e->e_id, 0 );
+		"====> bdb2i_cache_add_entry( %ld ): \"%s\": already in dn cache\n",
+		    e->e_id, e->e_dn, 0 );
+
+		cache_entry_private_destroy(e);
 
 		/* free cache mutex */
 		ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
@@ -138,8 +247,8 @@ bdb2i_cache_add_entry_lock(
 		entry_id_cmp, avl_dup_error ) != 0 )
 	{
 		Debug( LDAP_DEBUG_ANY,
-			"====> entry %20s id %lu already in id cache\n",
-		    e->e_dn, e->e_id, 0 );
+		"====> bdb2i_cache_add_entry( %ld ): \"%s\": already in id cache\n",
+		    e->e_id, e->e_dn, 0 );
 
 		/* delete from dn tree inserted above */
 		if ( avl_delete( &cache->c_dntree, (caddr_t) e,
@@ -149,13 +258,19 @@ bdb2i_cache_add_entry_lock(
 			    0, 0, 0 );
 		}
 
+		cache_entry_private_destroy(e);
+
 		/* free cache mutex */
 		ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
 		return( -1 );
 	}
 
-	e->e_state = state;
-	e->e_refcnt = 1;
+	cache_entry_rdwr_lock( e, rw );
+
+	/* put the entry into 'CREATING' state */
+	/* will be marked after when entry is returned */
+	LEI(e)->lei_state = CACHE_ENTRY_CREATING;
+	LEI(e)->lei_refcnt = 1;
 
 	/* lru */
 	LRU_ADD( cache, e );
@@ -166,8 +281,10 @@ bdb2i_cache_add_entry_lock(
 		 * first 10 on the tail of the list.
 		 */
 		i = 0;
-		while ( cache->c_lrutail != NULL && cache->c_lrutail->e_refcnt
-		    != 0 && i < 10 ) {
+		while ( cache->c_lrutail != NULL &&
+			LEI(cache->c_lrutail)->lei_refcnt != 0 &&
+			i < 10 )
+		{
 			/* move this in-use entry to the front of the q */
 			ee = cache->c_lrutail;
 			LRU_DELETE( cache, ee );
@@ -179,18 +296,118 @@ bdb2i_cache_add_entry_lock(
 		 * found at least one to delete - try to get back under
 		 * the max cache size.
 		 */
-		while ( cache->c_lrutail != NULL && cache->c_lrutail->e_refcnt
-                    == 0 && cache->c_cursize > cache->c_maxsize ) {
+		while ( cache->c_lrutail != NULL &&
+			LEI(cache->c_lrutail)->lei_refcnt == 0 &&
+			cache->c_cursize > cache->c_maxsize )
+		{
 			e = cache->c_lrutail;
 
-		/* check for active readers/writer lock */
+			/* delete from cache and lru q */
+			/* XXX do we need rc ? */
+			rc = cache_delete_entry_internal( cache, e );
+			cache_entry_private_destroy( e );
+			entry_free( e );
+		}
+	}
+
+	/* free cache mutex */
+	ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+	return( 0 );
+}
+
+/*
+ * cache_update_entry - update a LOCKED entry which has been deleted.
+ * returns:	0	entry has been created and locked
+ *		1	entry already existed
+ *		-1	something bad happened
+ */
+int
+bdb2i_cache_update_entry(
+    struct cache	*cache,
+    Entry		*e
+)
+{
+	int	i, rc;
+	Entry	*ee;
+
+	/* set cache mutex */
+	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
+
 #ifdef LDAP_DEBUG
-			assert(!ldap_pvt_thread_rdwr_active( &e->e_rdwr ));
+	assert( e->e_private );
 #endif
 
+	if ( avl_insert( &cache->c_dntree, (caddr_t) e,
+		entry_dn_cmp, avl_dup_error ) != 0 )
+	{
+		Debug( LDAP_DEBUG_TRACE,
+		"====> bdb2i_cache_add_entry( %ld ): \"%s\": already in dn cache\n",
+		    e->e_id, e->e_dn, 0 );
+
+		/* free cache mutex */
+		ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+		return( 1 );
+	}
+
+	/* id tree */
+	if ( avl_insert( &cache->c_idtree, (caddr_t) e,
+		entry_id_cmp, avl_dup_error ) != 0 )
+	{
+		Debug( LDAP_DEBUG_ANY,
+		"====> bdb2i_cache_update_entry( %ld ): \"%s\": already in id cache\n",
+		    e->e_id, e->e_dn, 0 );
+
+		/* delete from dn tree inserted above */
+		if ( avl_delete( &cache->c_dntree, (caddr_t) e,
+			entry_dn_cmp ) == NULL )
+		{
+			Debug( LDAP_DEBUG_ANY, "====> can't delete from dn cache\n",
+			    0, 0, 0 );
+		}
+
+		/* free cache mutex */
+		ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
+		return( -1 );
+	}
+
+	/* put the entry into 'CREATING' state */
+	/* will be marked after when entry is returned */
+	LEI(e)->lei_state = CACHE_ENTRY_CREATING;
+
+	/* lru */
+	LRU_ADD( cache, e );
+	if ( ++cache->c_cursize > cache->c_maxsize ) {
+		/*
+		 * find the lru entry not currently in use and delete it.
+		 * in case a lot of entries are in use, only look at the
+		 * first 10 on the tail of the list.
+		 */
+		i = 0;
+		while ( cache->c_lrutail != NULL &&
+			LEI(cache->c_lrutail)->lei_refcnt != 0 &&
+			i < 10 )
+		{
+			/* move this in-use entry to the front of the q */
+			ee = cache->c_lrutail;
+			LRU_DELETE( cache, ee );
+			LRU_ADD( cache, ee );
+			i++;
+		}
+
+		/*
+		 * found at least one to delete - try to get back under
+		 * the max cache size.
+		 */
+		while ( cache->c_lrutail != NULL &&
+			LEI(cache->c_lrutail)->lei_refcnt == 0 &&
+			cache->c_cursize > cache->c_maxsize )
+		{
+			e = cache->c_lrutail;
+
 			/* delete from cache and lru q */
+			/* XXX do we need rc ? */
 			rc = cache_delete_entry_internal( cache, e );
-
+			cache_entry_private_destroy( e );
 			entry_free( e );
 		}
 	}
@@ -231,20 +448,30 @@ bdb2i_cache_find_entry_dn2id(
 		 */
 		free(e.e_ndn);
 
-		Debug(LDAP_DEBUG_TRACE, "====> cache_find_entry_dn2id: found dn: %s\n",
-			dn, 0, 0);
+#ifdef LDAP_DEBUG
+		assert( ep->e_private );
+#endif
 
 		/*
 		 * entry is deleted or not fully created yet
 		 */
-		if ( ep->e_state == ENTRY_STATE_DELETED ||
-			ep->e_state == ENTRY_STATE_CREATING )
-		{
+		if ( LEI(ep)->lei_state != CACHE_ENTRY_READY ) {
+#ifdef LDAP_DEBUG
+			assert(LEI(ep)->lei_state != CACHE_ENTRY_UNDEFINED);
+#endif
+			Debug(LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_find_entry_dn2id(\"%s\"): %ld (not ready) %d\n",
+				dn, ep->e_id, LEI(ep)->lei_state);
+
 			/* free cache mutex */
 			ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
 			return( NOID );
 		}
 
+		Debug(LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_find_entry_dn2id(\"%s\"): %ld\n",
+			dn, ep->e_id, 0);
+
 		/* lru */
 		LRU_DELETE( cache, ep );
 		LRU_ADD( cache, ep );
@@ -289,23 +516,32 @@ try_again:
 	if ( (ep = (Entry *) avl_find( cache->c_idtree, (caddr_t) &e,
 		entry_id_cmp )) != NULL )
 	{
-		Debug(LDAP_DEBUG_TRACE,
-			"====> cache_find_entry_dn2id: found id: %ld rw: %d\n",
-			id, rw, 0);
+#ifdef LDAP_DEBUG
+		assert( ep->e_private );
+#endif
 
 		/*
 		 * entry is deleted or not fully created yet
 		 */
-		if ( ep->e_state == ENTRY_STATE_DELETED ||
-			ep->e_state == ENTRY_STATE_CREATING )
-		{
+		if ( LEI(ep)->lei_state != CACHE_ENTRY_READY ) {
+#ifdef LDAP_DEBUG
+			assert(LEI(ep)->lei_state != CACHE_ENTRY_UNDEFINED);
+#endif
+			Debug(LDAP_DEBUG_TRACE,
+				"====> bdb2i_cache_find_entry_id( %ld ): %ld (not ready) %d\n",
+				id, ep->e_id, LEI(ep)->lei_state);
+
 			/* free cache mutex */
 			ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
 			return( NULL );
 		}
 
+		Debug(LDAP_DEBUG_TRACE,
+			"====> bdb2i_cache_find_entry_id( %ld, %s ) \"%s\" (found)\n",
+			id, rw ? "w" : "r", ep->e_dn);
+
 		/* acquire reader lock */
-		if ( entry_rdwr_trylock(ep, rw) == LDAP_PVT_THREAD_EBUSY ) {
+		if ( cache_entry_rdwr_trylock(ep, rw) == LDAP_PVT_THREAD_EBUSY ) {
 			/* could not acquire entry lock...
 			 * owner cannot free as we have the cache locked.
 			 * so, unlock the cache, yield, and try again.
@@ -321,7 +557,7 @@ try_again:
 		LRU_DELETE( cache, ep );
 		LRU_ADD( cache, ep );
                 
-		ep->e_refcnt++;
+		LEI(ep)->lei_refcnt++;
 
 		/* free cache mutex */
 		ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
@@ -354,16 +590,16 @@ bdb2i_cache_delete_entry(
 {
 	int	rc;
 
-	Debug( LDAP_DEBUG_TRACE, "====> cache_delete_entry:\n", 0, 0, 0 );
-
 	/* set cache mutex */
 	ldap_pvt_thread_mutex_lock( &cache->c_mutex );
 
-	/* XXX check for writer lock - should also check no readers pending */
 #ifdef LDAP_DEBUG
-	assert(ldap_pvt_thread_rdwr_writers( &e->e_rdwr ) == 1);
+	assert( e->e_private );
 #endif
 
+	Debug( LDAP_DEBUG_TRACE, "====> bdb2i_cache_delete_entry( %ld )\n",
+		e->e_id, 0, 0 );
+
 	rc = cache_delete_entry_internal( cache, e );
 
 	/* free cache mutex */
@@ -404,7 +640,7 @@ cache_delete_entry_internal(
 	/*
 	 * flag entry to be freed later by a call to cache_return_entry()
 	 */
-	e->e_state = ENTRY_STATE_DELETED;
+	LEI(e)->lei_state = CACHE_ENTRY_DELETED;
 
 	return( 0 );
 }
@@ -417,14 +653,14 @@ lru_print( struct cache *cache )
 	Entry	*e;
 
 	fprintf( stderr, "LRU queue (head to tail):\n" );
-	for ( e = cache->c_lruhead; e != NULL; e = e->e_lrunext ) {
-		fprintf( stderr, "\tdn %20s id %lu refcnt %d\n", e->e_dn,
-		    e->e_id, e->e_refcnt );
+	for ( e = cache->c_lruhead; e != NULL; e = LEI(e)->lei_lrunext ) {
+		fprintf( stderr, "\tdn \"%20s\" id %ld refcnt %d\n",
+			e->e_dn, e->e_id, LEI(e)->lei_refcnt );
 	}
 	fprintf( stderr, "LRU queue (tail to head):\n" );
-	for ( e = cache->c_lrutail; e != NULL; e = e->e_lruprev ) {
-		fprintf( stderr, "\tdn %20s id %lu refcnt %d\n", e->e_dn,
-		    e->e_id, e->e_refcnt );
+	for ( e = cache->c_lrutail; e != NULL; e = LEI(e)->lei_lruprev ) {
+		fprintf( stderr, "\tdn \"%20s\" id %ld refcnt %d\n",
+			e->e_dn, e->e_id, LEI(e)->lei_refcnt );
 	}
 }
 
diff --git a/servers/slapd/back-bdb2/dn2id.c b/servers/slapd/back-bdb2/dn2id.c
index 1450775135..9de7630eb2 100644
--- a/servers/slapd/back-bdb2/dn2id.c
+++ b/servers/slapd/back-bdb2/dn2id.c
@@ -76,7 +76,7 @@ bdb2i_dn2id(
 	/* first check the cache */
 	if ( (id = bdb2i_cache_find_entry_dn2id( be, &li->li_cache, dn )) != NOID ) {
 		free( dn );
-		Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %lu (in cache)\n", id,
+		Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %ld (in cache)\n", id,
 			0, 0 );
 		return( id );
 	}
@@ -106,7 +106,7 @@ bdb2i_dn2id(
 
 	ldbm_datum_free( db->dbc_db, data );
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %lu\n", id, 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_dn2id %ld\n", id, 0, 0 );
 	return( id );
 }
 
@@ -153,8 +153,8 @@ bdb2i_dn2id_delete(
  * entry.
  */
 
-static Entry *
-dn2entry(
+Entry *
+bdb2i_dn2entry_rw(
     BackendDB	*be,
     char	*dn,
     char	**matched,
@@ -172,14 +172,14 @@ dn2entry(
 	*matched = NULL;
 
 	if ( (id = bdb2i_dn2id( be, dn )) != NOID &&
-		(e = bdb2i_id2entry( be, id, rw )) != NULL )
+		(e = bdb2i_id2entry_rw( be, id, rw )) != NULL )
 	{
 		return( e );
 	}
 
 	if ( id != NOID ) {
 		Debug(LDAP_DEBUG_ANY,
-			"dn2entry_%s: no entry for valid id (%lu), dn \"%s\"\n",
+			"dn2entry_%s: no entry for valid id (%ld), dn \"%s\"\n",
 			rw ? "w" : "r", id, dn);
 		/* must have been deleted from underneath us */
 		/* treat as if NOID was found */
@@ -208,25 +208,4 @@ dn2entry(
 	return( NULL );
 }
 
-Entry *
-bdb2i_dn2entry_r(
-	BackendDB	*be,
-	char	*dn,
-	char	**matched
-)
-{
-	return( dn2entry( be, dn, matched, 0 ) );
-}
-
-Entry *
-bdb2i_dn2entry_w(
-	BackendDB	*be,
-	char	*dn,
-	char	**matched
-)
-{
-	return( dn2entry( be, dn, matched, 1 ) );
-}
-
-
 
diff --git a/servers/slapd/back-bdb2/filterindex.c b/servers/slapd/back-bdb2/filterindex.c
index 88a854a8b5..d5cc90d95f 100644
--- a/servers/slapd/back-bdb2/filterindex.c
+++ b/servers/slapd/back-bdb2/filterindex.c
@@ -86,7 +86,7 @@ bdb2i_filter_candidates(
 		break;
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_filter_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_filter_candidates %ld\n",
 	    result ? ID_BLOCK_NIDS(result) : 0, 0, 0 );
 	return( result );
 }
@@ -117,7 +117,7 @@ ava_candidates(
 		break;
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= ava_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= ava_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
@@ -134,7 +134,7 @@ presence_candidates(
 
 	idl = bdb2i_index_read( be, type, 0, "*" );
 
-	Debug( LDAP_DEBUG_TRACE, "<= presence_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= presence_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
@@ -171,7 +171,7 @@ approx_candidates(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= approx_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= approx_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
@@ -212,7 +212,7 @@ list_candidates(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= list_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= list_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
@@ -279,7 +279,7 @@ substring_candidates(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= substring_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= substring_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
@@ -347,7 +347,7 @@ substring_comp_candidates(
 		}
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= substring_comp_candidates %lu\n",
+	Debug( LDAP_DEBUG_TRACE, "<= substring_comp_candidates %ld\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
diff --git a/servers/slapd/back-bdb2/id2children.c b/servers/slapd/back-bdb2/id2children.c
index 82a295efdb..83db5d07a8 100644
--- a/servers/slapd/back-bdb2/id2children.c
+++ b/servers/slapd/back-bdb2/id2children.c
@@ -25,7 +25,7 @@ bdb2i_id2children_add(
 
 	ldbm_datum_init( key );
 
-	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2children_add( %lu, %lu )\n",
+	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2children_add( %ld, %ld )\n",
 	       p ? p->e_id : 0, e->e_id, 0 );
 
 	if ( (db = bdb2i_cache_open( be, "id2children", BDB2_SUFFIX,
@@ -67,7 +67,7 @@ bdb2i_id2children_remove(
 	ID_BLOCK		*idl;
 	char		buf[20];
 
-	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2children_remove( %lu, %lu )\n",
+	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2children_remove( %ld, %ld )\n",
 		p ? p->e_id : 0, e->e_id, 0 );
 
 	if ( (db = bdb2i_cache_open( be, "id2children", BDB2_SUFFIX,
@@ -110,7 +110,7 @@ bdb2i_has_children(
 
 	ldbm_datum_init( key );
 
-	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_has_children( %lu )\n", p->e_id , 0, 0 );
+	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_has_children( %ld )\n", p->e_id , 0, 0 );
 
 	if ( (db = bdb2i_cache_open( be, "id2children", BDB2_SUFFIX,
 	    LDBM_WRCREAT )) == NULL ) {
@@ -133,7 +133,7 @@ bdb2i_has_children(
 		rc = 1;
 	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_has_children( %lu ): %s\n",
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_has_children( %ld ): %s\n",
 					p->e_id, rc ? "yes" : "no", 0 );
 	return( rc );
 }
diff --git a/servers/slapd/back-bdb2/id2entry.c b/servers/slapd/back-bdb2/id2entry.c
index 8507567055..bbcb8be1b1 100644
--- a/servers/slapd/back-bdb2/id2entry.c
+++ b/servers/slapd/back-bdb2/id2entry.c
@@ -9,6 +9,11 @@
 #include "slap.h"
 #include "back-bdb2.h"
 
+/*
+ * This routine adds (or updates) an entry on disk.
+ * The cache should already be updated.
+ */
+
 int
 bdb2i_id2entry_add( BackendDB *be, Entry *e )
 {
@@ -20,7 +25,7 @@ bdb2i_id2entry_add( BackendDB *be, Entry *e )
 	ldbm_datum_init( key );
 	ldbm_datum_init( data );
 
-	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2entry_add( %lu, \"%s\" )\n", e->e_id,
+	Debug( LDAP_DEBUG_TRACE, "=> bdb2i_id2entry_add( %ld, \"%s\" )\n", e->e_id,
 	    e->e_dn, 0 );
 
 	if ( (db = bdb2i_cache_open( be, "id2entry", BDB2_SUFFIX, LDBM_WRCREAT ))
@@ -45,11 +50,9 @@ bdb2i_id2entry_add( BackendDB *be, Entry *e )
 	ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
 
 	bdb2i_cache_close( be, db );
-	(void) bdb2i_cache_add_entry_lock( &li->li_cache, e, 0 );
 
 	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_id2entry_add %d\n", rc, 0, 0 );
 
-	/* XXX should entries be born locked, i.e. apply writer lock here? */
 	return( rc );
 }
 
@@ -61,12 +64,14 @@ bdb2i_id2entry_delete( BackendDB *be, Entry *e )
 	Datum		key;
 	int		rc;
 
-	Debug(LDAP_DEBUG_TRACE, "=> bdb2i_id2entry_delete( %lu, \"%s\" )\n", e->e_id,
+	Debug(LDAP_DEBUG_TRACE, "=> bdb2i_id2entry_delete( %ld, \"%s\" )\n", e->e_id,
 	    e->e_dn, 0 );
 
+#ifdef notdef
 #ifdef LDAP_DEBUG
 	/* check for writer lock */
-	assert(ldap_pvt_thread_rdwr_writers(&e->e_rdwr));
+	assert(ldap_pvt_thread_rdwr_writers(&e->e_rdwr) == 1);
+#endif
 #endif
 
 	ldbm_datum_init( key );
@@ -79,7 +84,7 @@ bdb2i_id2entry_delete( BackendDB *be, Entry *e )
 	}
 
 	if ( bdb2i_cache_delete_entry( &li->li_cache, e ) != 0 ) {
-		Debug(LDAP_DEBUG_ANY, "could not delete %lu (%s) from cache\n",
+		Debug(LDAP_DEBUG_ANY, "could not delete %ld (%s) from cache\n",
 		    e->e_id, e->e_dn, 0 );
 	}
 
@@ -94,9 +99,9 @@ bdb2i_id2entry_delete( BackendDB *be, Entry *e )
 	return( rc );
 }
 
-/* XXX returns entry with reader/writer lock */
+/* returns entry with reader/writer lock */
 Entry *
-bdb2i_id2entry( BackendDB *be, ID id, int rw )
+bdb2i_id2entry_rw( BackendDB *be, ID id, int rw )
 {
 	struct ldbminfo	*li = (struct ldbminfo *) be->be_private;
 	struct dbcache	*db;
@@ -110,8 +115,8 @@ bdb2i_id2entry( BackendDB *be, ID id, int rw )
 		rw ? "w" : "r", id, 0 );
 
 	if ( (e = bdb2i_cache_find_entry_id( &li->li_cache, id, rw )) != NULL ) {
-		Debug( LDAP_DEBUG_TRACE, "<= bdb2i_id2entry_%s 0x%lx (cache)\n",
-			rw ? "w" : "r", (unsigned long)e, 0 );
+		Debug( LDAP_DEBUG_TRACE, "<= bdb2i_id2entry_%s( %ld ) 0x%lx (cache)\n",
+			rw ? "w" : "r", id, (unsigned long)e );
 		return( e );
 	}
 
@@ -145,30 +150,26 @@ bdb2i_id2entry( BackendDB *be, ID id, int rw )
 		return( NULL );
 	}
 
-	/* acquire required reader/writer lock */
-	if (entry_rdwr_lock(e, rw)) {
-		/* XXX set DELETE flag?? */
-		entry_free(e);
-		return(NULL);
+	if ( e->e_id != id ) {
+		Debug( LDAP_DEBUG_TRACE,
+			"<= bdb2i_id2entry_%s( %ld ) (wrong id %ld on disk)\n",
+			rw ? "w" : "r", id, e->e_id );
+		entry_free( e );
+		return( NULL );
 	}
 
-	e->e_id = id;
-	(void) bdb2i_cache_add_entry_lock( &li->li_cache, e, 0 );
+	if ( bdb2i_cache_add_entry_rw( &li->li_cache, e, rw ) != 0 ) {
+		Debug( LDAP_DEBUG_TRACE,
+			"<= bdb2i_id2entry_%s( %ld ) (cache add failed)\n",
+			rw ? "w" : "r", id, 0 );
+		entry_free( e );
+		return( NULL );
+	}
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_id2entry_%s( %ld ) (disk)\n",
-		rw ? "w" : "r", id, 0 );
-	return( e );
-}
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_id2entry_%s( %ld ) 0x%lx (disk)\n",
+		rw ? "w" : "r", id, (unsigned long) e );
 
-Entry *
-bdb2i_id2entry_r( BackendDB *be, ID id )
-{
-	return( bdb2i_id2entry( be, id, 0 ) );
+	return( e );
 }
 
-Entry *
-bdb2i_id2entry_w( BackendDB *be, ID id )
-{
-	return( bdb2i_id2entry( be, id, 1 ) );
-}
 
diff --git a/servers/slapd/back-bdb2/idl.c b/servers/slapd/back-bdb2/idl.c
index dea359debc..d82078b3f7 100644
--- a/servers/slapd/back-bdb2/idl.c
+++ b/servers/slapd/back-bdb2/idl.c
@@ -181,7 +181,7 @@ bdb2i_idl_fetch(
 	}
 	free( (char *) tmp );
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_idl_fetch %lu ids (%lu max)\n",
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_idl_fetch %ld ids (%ld max)\n",
 	       ID_BLOCK_NIDS(idl), ID_BLOCK_NMAX(idl), 0 );
 	return( idl );
 }
@@ -500,7 +500,7 @@ bdb2i_idl_insert_key(
 			case 0:		/* id inserted */
 				if ( rc == 2 ) {
 					Debug( LDAP_DEBUG_ANY,
-					    "id %lu already in next block\n",
+					    "id %ld already in next block\n",
 					    id, 0, 0 );
 				}
 				free( kstr );
diff --git a/servers/slapd/back-bdb2/index.c b/servers/slapd/back-bdb2/index.c
index 15c82cf5ad..4344606632 100644
--- a/servers/slapd/back-bdb2/index.c
+++ b/servers/slapd/back-bdb2/index.c
@@ -111,7 +111,7 @@ bdb2i_index_read(
 	if ( ! (indextype & indexmask) ) {
 		idl =  bdb2i_idl_allids( be );
 		Debug( LDAP_DEBUG_TRACE,
-		    "<= bdb2i_index_read %lu candidates (allids - not indexed)\n",
+		    "<= bdb2i_index_read %ld candidates (allids - not indexed)\n",
 		    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 		return( idl );
 	}
@@ -151,7 +151,7 @@ bdb2i_index_read(
 
 	bdb2i_cache_close( be, db );
 
-	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_index_read %lu candidates\n",
+	Debug( LDAP_DEBUG_TRACE, "<= bdb2i_index_read %ld candidates\n",
 	    idl ? ID_BLOCK_NIDS(idl) : 0, 0, 0 );
 	return( idl );
 }
diff --git a/servers/slapd/back-bdb2/modrdn.c b/servers/slapd/back-bdb2/modrdn.c
index 717f653af7..d310ca0c7a 100644
--- a/servers/slapd/back-bdb2/modrdn.c
+++ b/servers/slapd/back-bdb2/modrdn.c
@@ -145,8 +145,9 @@ bdb2i_back_modrdn_internal(
 	free( e->e_ndn );
 	e->e_dn = new_dn;
 	e->e_ndn = new_ndn;
+	(void) bdb2i_cache_update_entry( &li->li_cache, e );
 
-	/* XXX
+	/*
 	 * At some point here we need to update the attribute values in
 	 * the entry itself that were effected by this RDN change
 	 * (respecting the value of the deleteoldrdn parameter).
diff --git a/servers/slapd/back-bdb2/nextid.c b/servers/slapd/back-bdb2/nextid.c
index 11c11e5cb1..711603a46c 100644
--- a/servers/slapd/back-bdb2/nextid.c
+++ b/servers/slapd/back-bdb2/nextid.c
@@ -42,7 +42,7 @@ next_id_read( BackendDB *be )
 
 	if(id < 1) {
 		Debug( LDAP_DEBUG_ANY,
-			"next_id_read %lu: atol(%s) return non-positive integer\n",
+			"next_id_read %ld: atol(%s) return non-positive integer\n",
 			id, buf, 0 );
 		return NOID;
 	}
@@ -60,7 +60,7 @@ next_id_write( BackendDB *be, ID id )
 	int		rc;
 
 	if ( (fp = fopen( file, "w" )) == NULL ) {
-		Debug( LDAP_DEBUG_ANY, "next_id_write(%lu): could not open \"%s\"\n",
+		Debug( LDAP_DEBUG_ANY, "next_id_write(%ld): could not open \"%s\"\n",
 		    id, file, 0 );
 		return -1;
 	} 
@@ -68,13 +68,13 @@ next_id_write( BackendDB *be, ID id )
 	rc = 0;
 
 	if ( fprintf( fp, "%ld\n", id ) == EOF ) {
-		Debug( LDAP_DEBUG_ANY, "next_id_write(%lu): cannot fprintf\n",
+		Debug( LDAP_DEBUG_ANY, "next_id_write(%ld): cannot fprintf\n",
 		    id, 0, 0 );
 		rc = -1;
 	}
 
 	if( fclose( fp ) != 0 ) {
-		Debug( LDAP_DEBUG_ANY, "next_id_write %lu: cannot fclose\n",
+		Debug( LDAP_DEBUG_ANY, "next_id_write %ld: cannot fclose\n",
 		    id, 0, 0 );
 		rc = -1;
 	}
diff --git a/servers/slapd/back-bdb2/proto-back-bdb2.h b/servers/slapd/back-bdb2/proto-back-bdb2.h
index 0a10c2cf1d..d66cf1826d 100644
--- a/servers/slapd/back-bdb2/proto-back-bdb2.h
+++ b/servers/slapd/back-bdb2/proto-back-bdb2.h
@@ -34,11 +34,13 @@ void bdb2i_attr_index_config LDAP_P(( struct ldbminfo *li, char *fname,
  * cache.c
  */
 
-void bdb2i_cache_set_state LDAP_P(( struct cache *cache, Entry *e, int state ));
-void bdb2i_cache_return_entry_r LDAP_P(( struct cache *cache, Entry *e ));
-void bdb2i_cache_return_entry_w LDAP_P(( struct cache *cache, Entry *e ));
-int bdb2i_cache_add_entry_lock LDAP_P(( struct cache *cache, Entry *e,
- int state ));
+int bdb2i_cache_add_entry_rw LDAP_P(( struct cache *cache, Entry *e, int rw ));
+int bdb2i_cache_update_entry LDAP_P(( struct cache *cache, Entry *e ));
+void bdb2i_cache_return_entry_rw LDAP_P(( struct cache *cache, Entry *e,
+ int rw ));
+#define bdb2i_cache_return_entry_r(c, e) bdb2i_cache_return_entry_rw((c), (e), 0)
+#define bdb2i_cache_return_entry_w(c, e) bdb2i_cache_return_entry_rw((c), (e), 1)
+
 ID bdb2i_cache_find_entry_dn2id LDAP_P(( BackendDB *be, struct cache *cache,
  char *dn ));
 Entry * bdb2i_cache_find_entry_id LDAP_P(( struct cache *cache, ID id, int rw ));
@@ -64,8 +66,11 @@ int bdb2i_cache_delete LDAP_P(( struct dbcache *db, Datum key ));
 int bdb2i_dn2id_add LDAP_P(( BackendDB *be, char *dn, ID id ));
 ID bdb2i_dn2id LDAP_P(( BackendDB *be, char *dn ));
 int bdb2i_dn2id_delete LDAP_P(( BackendDB *be, char *dn ));
-Entry * bdb2i_dn2entry_r LDAP_P(( BackendDB *be, char *dn, char **matched ));
-Entry * bdb2i_dn2entry_w LDAP_P(( BackendDB *be, char *dn, char **matched ));
+
+Entry * bdb2i_dn2entry_rw LDAP_P(( BackendDB *be, char *dn, char **matched,
+ int rw ));
+#define bdb2i_dn2entry_r(be, dn, m) bdb2i_dn2entry_rw((be), (dn), (m), 0)
+#define bdb2i_dn2entry_w(be, dn, m) bdb2i_dn2entry_rw((be), (dn), (m), 1)
 
 /*
  * filterindex.c
@@ -87,9 +92,10 @@ int bdb2i_has_children LDAP_P(( BackendDB *be, Entry *p ));
 
 int bdb2i_id2entry_add LDAP_P(( BackendDB *be, Entry *e ));
 int bdb2i_id2entry_delete LDAP_P(( BackendDB *be, Entry *e ));
-Entry * bdb2i_id2entry LDAP_P(( BackendDB *be, ID id, int rw )); 
-Entry * bdb2i_id2entry_r LDAP_P(( BackendDB *be, ID id ));
-Entry * bdb2i_id2entry_w LDAP_P(( BackendDB *be, ID id ));
+
+Entry * bdb2i_id2entry_rw LDAP_P(( BackendDB *be, ID id, int rw )); 
+#define bdb2i_id2entry_r(be, id)  bdb2i_id2entry_rw((be), (id), 0)
+#define bdb2i_id2entry_w(be, id)  bdb2i_id2entry_rw((be), (id), 1)
 
 /*
  * idl.c
diff --git a/servers/slapd/back-bdb2/search.c b/servers/slapd/back-bdb2/search.c
index 073fe951b2..5358d74f56 100644
--- a/servers/slapd/back-bdb2/search.c
+++ b/servers/slapd/back-bdb2/search.c
@@ -171,7 +171,7 @@ bdb2i_back_search_internal(
 
 		/* get the entry with reader lock */
 		if ( (e = bdb2i_id2entry_r( be, id )) == NULL ) {
-			Debug( LDAP_DEBUG_ARGS, "candidate %lu not found\n",
+			Debug( LDAP_DEBUG_ARGS, "candidate %ld not found\n",
 			       id, 0, 0 );
 			continue;
 		}
diff --git a/servers/slapd/back-ldbm/cache.c b/servers/slapd/back-ldbm/cache.c
index b23ca2a776..fe88ed895d 100644
--- a/servers/slapd/back-ldbm/cache.c
+++ b/servers/slapd/back-ldbm/cache.c
@@ -305,6 +305,7 @@ cache_add_entry_rw(
 			e = cache->c_lrutail;
 
 			/* delete from cache and lru q */
+			/* XXX do we need rc ? */
 			rc = cache_delete_entry_internal( cache, e );
 			cache_entry_private_destroy( e );
 			entry_free( e );
@@ -407,6 +408,7 @@ cache_update_entry(
 			e = cache->c_lrutail;
 
 			/* delete from cache and lru q */
+			/* XXX do we need rc ? */
 			rc = cache_delete_entry_internal( cache, e );
 			cache_entry_private_destroy( e );
 			entry_free( e );
diff --git a/servers/slapd/tools/ldif2id2children-bdb2.c b/servers/slapd/tools/ldif2id2children-bdb2.c
index deb5d9dedc..3144339f11 100644
--- a/servers/slapd/tools/ldif2id2children-bdb2.c
+++ b/servers/slapd/tools/ldif2id2children-bdb2.c
@@ -291,9 +291,9 @@ main( int argc, char **argv )
 					sprintf( buf2, "%c%ld", EQ_PREFIX, pid );
 					key.dptr = buf2;
 					key.dsize = strlen( buf2 ) + 1;
-					if ( idl_insert_key( be, db2, key, id )
+					if ( bdb2i_idl_insert_key( be, db2, key, id )
 					    != 0 ) {
-						perror( "idl_insert_key" );
+						perror( "bdb2i_idl_insert_key" );
 						exit( 1 );
 					}
 				}
diff --git a/servers/slapd/tools/ldif2index-bdb2.c b/servers/slapd/tools/ldif2index-bdb2.c
index 1c7f5331b2..ff427aab9e 100644
--- a/servers/slapd/tools/ldif2index-bdb2.c
+++ b/servers/slapd/tools/ldif2index-bdb2.c
@@ -108,7 +108,7 @@ main( int argc, char **argv )
 	li = (struct ldbminfo *) be->be_private;
 	li->li_dbcachewsync = 0;
 
-	attr_masks( be->be_private, attr, &indexmask, &syntaxmask );
+	bdb2i_attr_masks( be->be_private, attr, &indexmask, &syntaxmask );
 	if ( indexmask == 0 ) {
 		exit( 0 );
 	}
@@ -160,7 +160,7 @@ main( int argc, char **argv )
 					if ( strcasecmp( type, attr ) == 0 ) {
 						bv.bv_val = val;
 						bv.bv_len = vlen;
-						index_add_values( be, attr,
+						bdb2i_index_add_values( be, attr,
 						    vals, id );
 					}
 				}
diff --git a/servers/slapd/tools/ldif2ldbm-bdb2.c b/servers/slapd/tools/ldif2ldbm-bdb2.c
index 2e0ef1f8dd..ae1b64cb35 100644
--- a/servers/slapd/tools/ldif2ldbm-bdb2.c
+++ b/servers/slapd/tools/ldif2ldbm-bdb2.c
@@ -257,7 +257,7 @@ main( int argc, char **argv )
 				    avl_dup_error ) != 0 ) {
 					free( type );
 				} else {
-					attr_masks( be->be_private, type,
+					bdb2i_attr_masks( be->be_private, type,
 					    &indexmask, &syntaxmask );
 					if ( indexmask ) {
 						args[i - 2] = type;