extern int __lock_getlocker(DB_LOCKTAB *lt, u_int32_t locker, int create, DB_LOCKER **ret);
#define CURSOR_SETLOCKER(cursor, id) cursor->locker = id
-#define CURSOR_GETLOCKER(cursor) cursor->locker
+#define CURSOR_GETLOCKER(cursor) cursor->locker
+#define BDB_LOCKID(locker) locker->id
#else
typedef u_int32_t BDB_LOCKER;
#define CURSOR_SETLOCKER(cursor, id) cursor->locker = id
#define CURSOR_GETLOCKER(cursor) cursor->locker
+#define BDB_LOCKID(locker) locker
#endif
* to avoid conflicting with BDB's internal locks. So add a byte here
* that is always zero.
*/
- char bei_lockpad;
+ short bei_lockpad;
short bei_state;
#define CACHE_ENTRY_DELETED 1
#define TXN_ID(txn) (txn)->locker
#endif
+/* #undef BDB_LOG_DEBUG */
+
+#ifdef BDB_LOG_DEBUG
+
+/* env->log_printf appeared in 4.4 */
+#if DB_VERSION_FULL >= 0x04040000
+#define BDB_LOG_PRINTF(env,txn,fmt,...) (env)->log_printf((env),(txn),(fmt),__VA_ARGS__)
+#else
+extern int __db_logmsg(const DB_ENV *env, DB_TXN *txn, const char *op, u_int32_t flags,
+ const char *fmt,...);
+#define BDB_LOG_PRINTF(env,txn,fmt,...) __db_logmsg((env),(txn),"DIAGNOSTIC",0,(fmt),__VA_ARGS__)
+#endif
+
+#else /* !BDB_LOG_DEBUG */
+
+#define BDB_LOG_PRINTF(a,b,c,...)
+
+#endif /* BDB_LOG_DEBUG */
+
#endif
#ifndef DB_BUFFER_SMALL
* alternatives though.
*/
-#if DB_VERSION_FULL >= 0x04060012
-#define BDB_LOCKID(locker) locker->id
-#else
-#define BDB_LOCKID(locker) locker
-#endif
-
/* Atomically release and reacquire a lock */
int
bdb_cache_entry_db_relock(
ei->bei_rdn.bv_val = NULL;
#endif
} else {
+ int rc;
+
bdb->bi_cache.c_eiused++;
ber_dupbv( &ei2->bei_nrdn, &ei->bei_nrdn );
*/
if ( ei->bei_parent->bei_kids || !ei->bei_parent->bei_id )
bdb->bi_cache.c_leaves++;
- avl_insert( &ei->bei_parent->bei_kids, ei2, bdb_rdn_cmp,
+ rc = avl_insert( &ei->bei_parent->bei_kids, ei2, bdb_rdn_cmp,
avl_dup_error );
+ if ( rc ) {
+ /* This should never happen; entry cache is corrupt */
+ bdb->bi_dbenv->log_flush( bdb->bi_dbenv, NULL );
+ assert( !rc );
+ }
#ifdef BDB_HIER
ei->bei_parent->bei_ckids++;
#endif
int
bdb_cache_find_ndn(
Operation *op,
- DB_TXN *txn,
+ BDB_LOCKER locker,
struct berval *ndn,
EntryInfo **res )
{
ei.bei_parent = eip;
ei2 = (EntryInfo *)avl_find( eip->bei_kids, &ei, bdb_rdn_cmp );
if ( !ei2 ) {
+ DB_LOCK lock;
int len = ei.bei_nrdn.bv_len;
if ( BER_BVISEMPTY( ndn )) {
(ei.bei_nrdn.bv_val - ndn->bv_val);
bdb_cache_entryinfo_unlock( eip );
- rc = bdb_dn2id( op, txn, &ei.bei_nrdn, &ei );
+ BDB_LOG_PRINTF( bdb->bi_dbenv, NULL, "slapd Reading %s",
+ ei.bei_nrdn.bv_val );
+
+ lock.mode = DB_LOCK_NG;
+ rc = bdb_dn2id( op, &ei.bei_nrdn, &ei, locker, &lock );
if (rc) {
bdb_cache_entryinfo_lock( eip );
+ bdb_cache_entry_db_unlock( bdb, &lock );
*res = eip;
return rc;
}
+ BDB_LOG_PRINTF( bdb->bi_dbenv, NULL, "slapd Read got %s(%d)",
+ ei.bei_nrdn.bv_val, ei.bei_id );
+
/* DN exists but needs to be added to cache */
ei.bei_nrdn.bv_len = len;
rc = bdb_entryinfo_add_internal( bdb, &ei, &ei2 );
/* add_internal left eip and c_rwlock locked */
ldap_pvt_thread_rdwr_wunlock( &bdb->bi_cache.c_rwlock );
+ bdb_cache_entry_db_unlock( bdb, &lock );
if ( rc ) {
*res = eip;
return rc;
int
hdb_cache_find_parent(
Operation *op,
- DB_TXN *txn,
BDB_LOCKER locker,
ID id,
EntryInfo **res )
ei.bei_ckids = 0;
for (;;) {
- rc = hdb_dn2id_parent( op, txn, locker, &ei, &eip.bei_id );
+ rc = hdb_dn2id_parent( op, locker, &ei, &eip.bei_id );
if ( rc ) break;
/* Save the previous node, if any */
#ifndef BDB_HIER
rc = bdb_id2entry( op->o_bd, tid, locker, id, &ep );
if ( rc == 0 ) {
- rc = bdb_cache_find_ndn( op, tid,
+ rc = bdb_cache_find_ndn( op, locker,
&ep->e_nname, eip );
if ( *eip ) flag |= ID_LOCKED;
if ( rc ) {
}
}
#else
- rc = hdb_cache_find_parent(op, tid, locker, id, eip );
+ rc = hdb_cache_find_parent(op, locker, id, eip );
if ( rc == 0 ) flag |= ID_LOCKED;
#endif
}
goto return_results;
}
+ BDB_LOG_PRINTF( bdb->bi_dbenv, lt2, "slapd Starting delete %s(%d)",
+ e->e_nname.bv_val, e->e_id );
+
/* Can't do it if we have kids */
rs->sr_err = bdb_cache_children( op, lt2, e );
if( rs->sr_err != DB_NOTFOUND ) {
p = NULL;
}
+ BDB_LOG_PRINTF( bdb->bi_dbenv, lt2, "slapd Commit1 delete %s(%d)",
+ e->e_nname.bv_val, e->e_id );
+
if ( TXN_COMMIT( lt2, 0 ) != 0 ) {
rs->sr_err = LDAP_OTHER;
rs->sr_text = "txn_commit(2) failed";
goto return_results;
}
} else {
+
+ BDB_LOG_PRINTF( bdb->bi_dbenv, ltid, "slapd Cache delete %s(%d)",
+ e->e_nname.bv_val, e->e_id );
+
rc = bdb_cache_delete( bdb, e, locker, &lock );
switch( rc ) {
case DB_LOCK_DEADLOCK:
ltid = NULL;
op->o_private = NULL;
+ BDB_LOG_PRINTF( bdb->bi_dbenv, NULL, "slapd Committed delete %s(%d)",
+ e->e_nname.bv_val, e->e_id );
+
if( rs->sr_err != 0 ) {
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(bdb_delete) ": txn_%s failed: %s (%d)\n",
*e = NULL;
- rc = bdb_cache_find_ndn( op, tid, dn, &ei );
+ rc = bdb_cache_find_ndn( op, locker, dn, &ei );
if ( rc ) {
if ( matched && rc == DB_NOTFOUND ) {
/* Set the return value, whether we have its entry
#include "idl.h"
#include "lutil.h"
+#define bdb_dn2id_lock BDB_SYMBOL(dn2id_lock)
+
+static int
+bdb_dn2id_lock( struct bdb_info *bdb, struct berval *dn,
+ int rw, BDB_LOCKER locker, DB_LOCK *lock )
+{
+ int rc;
+ DBT lockobj;
+ int db_rw;
+
+ if (rw)
+ db_rw = DB_LOCK_WRITE;
+ else
+ db_rw = DB_LOCK_READ;
+
+ lockobj.data = dn->bv_val;
+ lockobj.size = dn->bv_len;
+
+ rc = LOCK_GET(bdb->bi_dbenv, BDB_LOCKID(locker), DB_LOCK_NOWAIT,
+ &lockobj, db_rw, lock);
+ return rc;
+}
+
#ifndef BDB_HIER
int
bdb_dn2id_add(
{
struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
DB *db = bdb->bi_dn2id->bdi_db;
- int rc;
- DBT key;
char *buf;
+ DBT key;
+ DB_LOCK lock;
struct berval pdn, ptr;
+ int rc;
Debug( LDAP_DEBUG_TRACE, "=> bdb_dn2id_delete( \"%s\", 0x%08lx )\n",
e->e_ndn, e->e_id, 0 );
AC_MEMCPY( ptr.bv_val, e->e_nname.bv_val, e->e_nname.bv_len );
ptr.bv_val[ptr.bv_len] = '\0';
+ /* We hold this lock until the TXN completes */
+ rc = bdb_dn2id_lock( bdb, &e->e_nname, 1, TXN_ID( txn ), &lock );
+ if ( rc ) return rc;
+
/* delete it */
rc = db->del( db, txn, &key, 0 );
if( rc != 0 ) {
int
bdb_dn2id(
Operation *op,
- DB_TXN *txn,
struct berval *dn,
- EntryInfo *ei )
+ EntryInfo *ei,
+ BDB_LOCKER locker,
+ DB_LOCK *lock )
{
struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
DB *db = bdb->bi_dn2id->bdi_db;
+ DBC *cursor;
int rc;
DBT key, data;
ID nid;
data.ulen = sizeof(ID);
data.flags = DB_DBT_USERMEM;
+ rc = bdb_dn2id_lock( bdb, dn, 0, locker, lock );
+ if ( rc ) return rc;
+
+ rc = db->cursor( db, NULL, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+ if ( locker ) {
+ CURSOR_SETLOCKER(cursor, locker);
+ }
+
/* fetch it */
- rc = db->get( db, txn, &key, &data, bdb->bi_db_opflags );
+ rc = cursor->c_get( cursor, &key, &data, DB_SET );
if( rc != 0 ) {
Debug( LDAP_DEBUG_TRACE, "<= bdb_dn2id: get failed: %s (%d)\n",
ei->bei_id, 0, 0 );
}
+ cursor->c_close( cursor );
op->o_tmpfree( key.data, op->o_tmpmemctx );
return rc;
}
int rc;
ID nid;
unsigned char dlen[2];
+ DB_LOCK lock;
DBTzero(&key);
key.size = sizeof(ID);
data.dlen = data.size;
data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
+ /* We hold this lock until the TXN completes */
+ rc = bdb_dn2id_lock( bdb, &e->e_nname, 1, TXN_ID( txn ), &lock );
+ if ( rc ) return rc;
+
key.data = &nid;
rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
if ( rc ) return rc;
int
hdb_dn2id(
Operation *op,
- DB_TXN *txn,
struct berval *in,
- EntryInfo *ei )
+ EntryInfo *ei,
+ BDB_LOCKER locker,
+ DB_LOCK *lock )
{
struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
DB *db = bdb->bi_dn2id->bdi_db;
data.dlen = data.ulen;
data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
- rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ rc = bdb_dn2id_lock( bdb, in, 0, locker, lock );
if ( rc ) return rc;
+ rc = db->cursor( db, NULL, &cursor, bdb->bi_db_opflags );
+ if ( rc ) return rc;
+ if ( locker ) {
+ CURSOR_SETLOCKER( cursor, locker );
+ }
+
d = op->o_tmpalloc( data.size * 3, op->o_tmpmemctx );
d->nrdnlen[1] = nrlen & 0xff;
d->nrdnlen[0] = (nrlen >> 8) | 0x80;
int
hdb_dn2id_parent(
Operation *op,
- DB_TXN *txn,
BDB_LOCKER locker,
EntryInfo *ei,
ID *idp )
DBTzero(&data);
data.flags = DB_DBT_USERMEM;
- rc = db->cursor( db, txn, &cursor, bdb->bi_db_opflags );
+ rc = db->cursor( db, NULL, &cursor, bdb->bi_db_opflags );
if ( rc ) return rc;
- if ( !txn && locker ) {
+ if ( locker ) {
CURSOR_SETLOCKER(cursor, locker);
}
BDB_IDL_ZERO( ids );
if ( mra->ma_rule == slap_schema.si_mr_distinguishedNameMatch ) {
ei = NULL;
- rc = bdb_cache_find_ndn( op, NULL, &mra->ma_value, &ei );
+ rc = bdb_cache_find_ndn( op, locker, &mra->ma_value, &ei );
if ( rc == LDAP_SUCCESS )
bdb_idl_insert( ids, ei->bei_id );
if ( ei )
struct berval pdn;
ei = NULL;
dnParent( &mra->ma_value, &pdn );
- bdb_cache_find_ndn( op, NULL, &pdn, &ei );
+ bdb_cache_find_ndn( op, locker, &pdn, &ei );
if ( ei ) {
bdb_cache_entryinfo_unlock( ei );
while ( ei && ei->bei_id ) {
scope = LDAP_SCOPE_BASE;
if ( scope > LDAP_SCOPE_BASE ) {
ei = NULL;
- rc = bdb_cache_find_ndn( op, NULL, &mra->ma_value, &ei );
+ rc = bdb_cache_find_ndn( op, locker, &mra->ma_value, &ei );
if ( ei )
bdb_cache_entryinfo_unlock( ei );
if ( rc == LDAP_SUCCESS ) {
/* Shortcut the search */
nei = neip ? neip : eip;
- rs->sr_err = bdb_cache_find_ndn ( op, ltid, &new_ndn, &nei );
+ rs->sr_err = bdb_cache_find_ndn ( op, locker, &new_ndn, &nei );
if ( nei ) bdb_cache_entryinfo_unlock( nei );
switch( rs->sr_err ) {
case DB_LOCK_DEADLOCK:
int bdb_dn2id(
Operation *op,
- DB_TXN *tid,
struct berval *dn,
- EntryInfo *ei );
+ EntryInfo *ei,
+ BDB_LOCKER locker,
+ DB_LOCK *lock );
int bdb_dn2id_add(
Operation *op,
int bdb_dn2id_parent(
Operation *op,
- DB_TXN *txn,
BDB_LOCKER locker,
EntryInfo *ei,
ID *idp );
);
int bdb_cache_find_ndn(
Operation *op,
- DB_TXN *txn,
+ BDB_LOCKER locker,
struct berval *ndn,
EntryInfo **res
);
int
bdb_cache_find_parent(
Operation *op,
- DB_TXN *txn,
BDB_LOCKER locker,
ID id,
EntryInfo **res
op.o_tmpmemctx = NULL;
op.o_tmpmfuncs = &ch_mfuncs;
- rc = bdb_cache_find_ndn( &op, NULL, dn, &ei );
+ rc = bdb_cache_find_ndn( &op, 0, dn, &ei );
if ( ei ) bdb_cache_entryinfo_unlock( ei );
if ( rc == DB_NOTFOUND )
return NOID;
op.o_tmpmemctx = NULL;
op.o_tmpmfuncs = &ch_mfuncs;
- rc = bdb_cache_find_parent( &op, NULL, CURSOR_GETLOCKER(cursor), id, &ei );
+ rc = bdb_cache_find_parent( &op, CURSOR_GETLOCKER(cursor), id, &ei );
if ( rc == LDAP_SUCCESS ) {
bdb_cache_entryinfo_unlock( ei );
e->e_private = ei;
return 0;
}
- rc = bdb_cache_find_ndn( op, tid, &ndn, &ei );
+ rc = bdb_cache_find_ndn( op, TXN_ID( tid ), &ndn, &ei );
if ( ei ) bdb_cache_entryinfo_unlock( ei );
if ( rc == DB_NOTFOUND ) {
if ( !be_issuffix( op->o_bd, &ndn ) ) {