/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2000-2008 The OpenLDAP Foundation.
+ * Copyright 2000-2011 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
Operation *op,
SlapReply *rs,
Entry *e,
- BDB_LOCKER locker,
+ DB_TXN *txn,
ID *ids,
ID *scopes );
SlapReply *rs,
Entry *e,
Entry **matched,
- BDB_LOCKER locker,
+ DB_TXN *txn,
DB_LOCK *lock,
ID *tmp,
ID *visited )
break;
}
- rs->sr_err = bdb_dn2entry( op, NULL, &ndn, &ei,
- 0, locker, &lockr );
+ rs->sr_err = bdb_dn2entry( op, txn, &ndn, &ei,
+ 0, &lockr );
+ if ( rs->sr_err == DB_LOCK_DEADLOCK )
+ return NULL;
if ( ei ) {
e = ei->bei_e;
Operation *op,
SlapReply *rs,
Entry *e,
- BDB_LOCKER locker,
+ DB_TXN *txn,
ID *ids,
ID *scopes,
ID *stack )
/* Find all aliases in database */
BDB_IDL_ZERO( aliases );
- rs->sr_err = bdb_filter_candidates( op, locker, &af, aliases,
+ rs->sr_err = bdb_filter_candidates( op, txn, &af, aliases,
curscop, visited );
if (rs->sr_err != LDAP_SUCCESS) {
return rs->sr_err;
* to the cumulative list of candidates.
*/
BDB_IDL_CPY( curscop, aliases );
- rs->sr_err = bdb_dn2idl( op, locker, &e->e_nname, BEI(e), subscop,
+ rs->sr_err = bdb_dn2idl( op, txn, &e->e_nname, BEI(e), subscop,
subscop2+BDB_IDL_DB_SIZE );
+
if (first) {
first = 0;
} else {
bdb_cache_return_entry_r (bdb, e, &locka);
}
+ if ( rs->sr_err == DB_LOCK_DEADLOCK )
+ return rs->sr_err;
+
BDB_IDL_CPY(subscop2, subscop);
rs->sr_err = bdb_idl_intersection(curscop, subscop);
bdb_idl_union( ids, subscop2 );
{
ei = NULL;
retry1:
- rs->sr_err = bdb_cache_find_id(op, NULL,
- ida, &ei, 0, locker, &lockr );
+ rs->sr_err = bdb_cache_find_id(op, txn,
+ ida, &ei, 0, &lockr );
if (rs->sr_err != LDAP_SUCCESS) {
- if ( rs->sr_err == DB_LOCK_DEADLOCK ||
- rs->sr_err == DB_LOCK_NOTGRANTED ) goto retry1;
+ if ( rs->sr_err == DB_LOCK_DEADLOCK )
+ return rs->sr_err;
+ if ( rs->sr_err == DB_LOCK_NOTGRANTED )
+ goto retry1;
continue;
}
a = ei->bei_e;
/* Actually dereference the alias */
BDB_IDL_ZERO(tmp);
- a = deref_base( op, rs, a, &matched, locker, &lockr,
+ a = deref_base( op, rs, a, &matched, txn, &lockr,
tmp, visited );
if (a) {
/* If the target was not already in our current candidates,
}
bdb_cache_return_entry_r( bdb, a, &lockr);
+ } else if ( rs->sr_err == DB_LOCK_DEADLOCK ) {
+ return rs->sr_err;
} else if (matched) {
/* Alias could not be dereferenced, or it deref'd to
* an ID we've already seen. Ignore it.
*/
ei = NULL;
sameido:
- rs->sr_err = bdb_cache_find_id(op, NULL, ido, &ei,
- 0, locker, &locka );
+ rs->sr_err = bdb_cache_find_id(op, txn, ido, &ei,
+ 0, &locka );
if ( rs->sr_err != LDAP_SUCCESS ) {
- if ( rs->sr_err == DB_LOCK_DEADLOCK ||
- rs->sr_err == DB_LOCK_NOTGRANTED )
+ if ( rs->sr_err == DB_LOCK_DEADLOCK )
+ return rs->sr_err;
+ if ( rs->sr_err == DB_LOCK_NOTGRANTED )
goto sameido;
goto nextido;
}
return rs->sr_err;
}
+/* Get the next ID from the DB. Used if the candidate list is
+ * a range and simple iteration hits missing entryIDs
+ */
+static int
+bdb_get_nextid(struct bdb_info *bdb, DB_TXN *ltid, ID *cursor)
+{
+ DBC *curs;
+ DBT key, data;
+ ID id, nid;
+ int rc;
+
+ id = *cursor + 1;
+ BDB_ID2DISK( id, &nid );
+ rc = bdb->bi_id2entry->bdi_db->cursor(
+ bdb->bi_id2entry->bdi_db, ltid, &curs, bdb->bi_db_opflags );
+ if ( rc )
+ return rc;
+ key.data = &nid;
+ key.size = key.ulen = sizeof(ID);
+ key.flags = DB_DBT_USERMEM;
+ data.flags = DB_DBT_USERMEM | DB_DBT_PARTIAL;
+ data.dlen = data.ulen = 0;
+ rc = curs->c_get( curs, &key, &data, DB_SET_RANGE );
+ curs->c_close( curs );
+ if ( rc )
+ return rc;
+ BDB_DISK2ID( &nid, cursor );
+ return 0;
+}
+
int
bdb_search( Operation *op, SlapReply *rs )
{
slap_mask_t mask;
time_t stoptime;
int manageDSAit;
- int tentries = 0, nentries = 0;
+ int tentries = 0;
+ unsigned nentries = 0;
int idflag = 0;
- BDB_LOCKER locker = 0;
DB_LOCK lock;
struct bdb_op_info *opinfo = NULL;
DB_TXN *ltid = NULL;
attrs = op->oq_search.rs_attrs;
LDAP_SLIST_FOREACH( oex, &op->o_extra, oe_next ) {
- if ( oex->oe_key == (void *)op->o_bd->bd_self )
+ if ( oex->oe_key == bdb )
break;
}
opinfo = (struct bdb_op_info *) oex;
if ( opinfo && opinfo->boi_txn ) {
ltid = opinfo->boi_txn;
- locker = TXN_ID( ltid );
} else {
- rs->sr_err = LOCK_ID( bdb->bi_dbenv, &locker );
+ rs->sr_err = bdb_reader_get( op, bdb->bi_dbenv, <id );
switch(rs->sr_err) {
case 0:
dn2entry_retry:
/* get entry with reader lock */
rs->sr_err = bdb_dn2entry( op, ltid, &op->o_req_ndn, &ei,
- 1, locker, &lock );
+ 1, &lock );
}
switch(rs->sr_err) {
case 0:
e = ei->bei_e;
break;
+ case DB_LOCK_DEADLOCK:
+ if ( !opinfo ) {
+ ltid->flags &= ~TXN_DEADLOCK;
+ goto dn2entry_retry;
+ }
+ opinfo->boi_err = rs->sr_err;
+ /* FALLTHRU */
case LDAP_BUSY:
send_ldap_error( op, rs, LDAP_BUSY, "ldap server busy" );
- if ( !opinfo )
- LOCK_ID_FREE (bdb->bi_dbenv, locker );
return LDAP_BUSY;
- case DB_LOCK_DEADLOCK:
case DB_LOCK_NOTGRANTED:
goto dn2entry_retry;
default:
send_ldap_error( op, rs, LDAP_OTHER, "internal error" );
- if ( !opinfo )
- LOCK_ID_FREE (bdb->bi_dbenv, locker );
return rs->sr_err;
}
stub.bv_val = op->o_req_ndn.bv_val;
stub.bv_len = op->o_req_ndn.bv_len - matched->e_nname.bv_len - 1;
- e = deref_base( op, rs, matched, &matched, locker, &lock,
+ e = deref_base( op, rs, matched, &matched, ltid, &lock,
candidates, NULL );
if ( e ) {
build_new_dn( &op->o_req_ndn, &e->e_nname, &stub,
goto dn2entry_retry;
}
} else if ( e && is_entry_alias( e )) {
- e = deref_base( op, rs, e, &matched, locker, &lock,
+ e = deref_base( op, rs, e, &matched, ltid, &lock,
candidates, NULL );
}
}
send_ldap_result( op, rs );
- if ( !opinfo )
- LOCK_ID_FREE (bdb->bi_dbenv, locker );
if ( rs->sr_ref ) {
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
rs->sr_matched = matched_dn.bv_val;
send_ldap_result( op, rs );
- if ( !opinfo ) {
- LOCK_ID_FREE (bdb->bi_dbenv, locker );
- }
ber_bvarray_free( rs->sr_ref );
rs->sr_ref = NULL;
ber_memfree( matched_dn.bv_val );
rs->sr_err = base_candidate( op->o_bd, &base, candidates );
} else {
+cand_retry:
BDB_IDL_ZERO( candidates );
BDB_IDL_ZERO( scopes );
rs->sr_err = search_candidates( op, rs, &base,
- locker, candidates, scopes );
+ ltid, candidates, scopes );
+ if ( rs->sr_err == DB_LOCK_DEADLOCK ) {
+ if ( !opinfo ) {
+ ltid->flags &= ~TXN_DEADLOCK;
+ goto cand_retry;
+ }
+ opinfo->boi_err = rs->sr_err;
+ send_ldap_error( op, rs, LDAP_BUSY, "ldap server busy" );
+ return LDAP_BUSY;
+ }
}
/* start cursor at beginning of candidates.
/* check for abandon */
if ( op->o_abandon ) {
rs->sr_err = SLAPD_ABANDON;
+ send_ldap_result( op, rs );
goto done;
}
* any subsequent entries
*/
nentries++;
- if ( nentries > bdb->bi_cache.c_maxsize && !idflag )
+ if ( nentries > bdb->bi_cache.c_maxsize && !idflag ) {
idflag = ID_NOCACHE;
+ }
fetch_entry_retry:
- /* get the entry with reader lock */
- ei = NULL;
- rs->sr_err = bdb_cache_find_id( op, ltid,
- id, &ei, idflag, locker, &lock );
+ /* get the entry with reader lock */
+ ei = NULL;
+ rs->sr_err = bdb_cache_find_id( op, ltid,
+ id, &ei, idflag, &lock );
- if (rs->sr_err == LDAP_BUSY) {
- rs->sr_text = "ldap server busy";
- send_ldap_result( op, rs );
- goto done;
+ if (rs->sr_err == LDAP_BUSY) {
+ rs->sr_text = "ldap server busy";
+ send_ldap_result( op, rs );
+ goto done;
- } else if ( rs->sr_err == DB_LOCK_DEADLOCK
- || rs->sr_err == DB_LOCK_NOTGRANTED )
- {
+ } else if ( rs->sr_err == DB_LOCK_DEADLOCK ) {
+ if ( !opinfo ) {
+ ltid->flags &= ~TXN_DEADLOCK;
goto fetch_entry_retry;
- } else if ( rs->sr_err == LDAP_OTHER ) {
- rs->sr_text = "internal error";
- send_ldap_result( op, rs );
- goto done;
}
+txnfail:
+ opinfo->boi_err = rs->sr_err;
+ send_ldap_error( op, rs, LDAP_BUSY, "ldap server busy" );
+ goto done;
- if ( ei && rs->sr_err == LDAP_SUCCESS ) {
- e = ei->bei_e;
- } else {
- e = NULL;
- }
+ } else if ( rs->sr_err == DB_LOCK_NOTGRANTED )
+ {
+ goto fetch_entry_retry;
+ } else if ( rs->sr_err == LDAP_OTHER ) {
+ rs->sr_text = "internal error";
+ send_ldap_result( op, rs );
+ goto done;
+ }
- if ( e == NULL ) {
- if( !BDB_IDL_IS_RANGE(candidates) ) {
- /* only complain for non-range IDLs */
- Debug( LDAP_DEBUG_TRACE,
- LDAP_XSTRING(bdb_search)
- ": candidate %ld not found\n",
- (long) id, 0, 0 );
- }
+ if ( ei && rs->sr_err == LDAP_SUCCESS ) {
+ e = ei->bei_e;
+ } else {
+ e = NULL;
+ }
- goto loop_continue;
+ if ( e == NULL ) {
+ if( !BDB_IDL_IS_RANGE(candidates) ) {
+ /* only complain for non-range IDLs */
+ Debug( LDAP_DEBUG_TRACE,
+ LDAP_XSTRING(bdb_search)
+ ": candidate %ld not found\n",
+ (long) id, 0, 0 );
+ } else {
+ /* get the next ID from the DB */
+id_retry:
+ rs->sr_err = bdb_get_nextid( bdb, ltid, &cursor );
+ if ( rs->sr_err == DB_NOTFOUND ) {
+ break;
+ } else if ( rs->sr_err == DB_LOCK_DEADLOCK ) {
+ if ( opinfo )
+ goto txnfail;
+ ltid->flags &= ~TXN_DEADLOCK;
+ goto id_retry;
+ } else if ( rs->sr_err == DB_LOCK_NOTGRANTED ) {
+ goto id_retry;
+ }
+ if ( rs->sr_err ) {
+ rs->sr_err = LDAP_OTHER;
+ rs->sr_text = "internal error in get_nextid";
+ send_ldap_result( op, rs );
+ goto done;
+ }
+ cursor--;
}
- rs->sr_entry = e;
+ goto loop_continue;
+ }
if ( is_entry_subentry( e ) ) {
if( op->oq_search.rs_scope != LDAP_SCOPE_BASE ) {
if ( !manageDSAit && op->oq_search.rs_scope != LDAP_SCOPE_BASE
&& is_entry_referral( e ) )
{
+ struct bdb_op_info bois;
+ struct bdb_lock_info blis;
BerVarray erefs = get_entry_referrals( op, e );
rs->sr_ref = referral_rewrite( erefs, &e->e_name, NULL,
op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL
? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE );
+ /* Must set lockinfo so that entry_release will work */
+ if (!opinfo) {
+ bois.boi_oe.oe_key = bdb;
+ bois.boi_txn = NULL;
+ bois.boi_err = 0;
+ bois.boi_acl_cache = op->o_do_not_cache;
+ bois.boi_flag = BOI_DONTFREE;
+ bois.boi_locks = &blis;
+ blis.bli_next = NULL;
+ LDAP_SLIST_INSERT_HEAD( &op->o_extra, &bois.boi_oe,
+ oe_next );
+ } else {
+ blis.bli_next = opinfo->boi_locks;
+ opinfo->boi_locks = &blis;
+ }
+ blis.bli_id = e->e_id;
+ blis.bli_lock = lock;
+ blis.bli_flag = BLI_DONTFREE;
+
+ rs->sr_entry = e;
+ rs->sr_flags = REP_ENTRY_MUSTRELEASE;
+
send_search_reference( op, rs );
+ if ( blis.bli_flag ) {
+#ifdef SLAP_ZONE_ALLOC
+ slap_zn_runlock(bdb->bi_cache.c_zctx, e);
+#endif
+ bdb_cache_return_entry_r(bdb, e, &lock);
+ if ( opinfo ) {
+ opinfo->boi_locks = blis.bli_next;
+ } else {
+ LDAP_SLIST_REMOVE( &op->o_extra, &bois.boi_oe,
+ OpExtra, oe_next );
+ }
+ }
+ rs->sr_entry = NULL;
+ e = NULL;
+
ber_bvarray_free( rs->sr_ref );
ber_bvarray_free( erefs );
rs->sr_ref = NULL;
}
/* if it matches the filter and scope, send it */
- rs->sr_err = test_filter( op, rs->sr_entry, op->oq_search.rs_filter );
+ rs->sr_err = test_filter( op, e, op->oq_search.rs_filter );
if ( rs->sr_err == LDAP_COMPARE_TRUE ) {
/* check size limit */
}
if (e) {
+ struct bdb_op_info bois;
+ struct bdb_lock_info blis;
+
+ /* Must set lockinfo so that entry_release will work */
+ if (!opinfo) {
+ bois.boi_oe.oe_key = bdb;
+ bois.boi_txn = NULL;
+ bois.boi_err = 0;
+ bois.boi_acl_cache = op->o_do_not_cache;
+ bois.boi_flag = BOI_DONTFREE;
+ bois.boi_locks = &blis;
+ blis.bli_next = NULL;
+ LDAP_SLIST_INSERT_HEAD( &op->o_extra, &bois.boi_oe,
+ oe_next );
+ } else {
+ blis.bli_next = opinfo->boi_locks;
+ opinfo->boi_locks = &blis;
+ }
+ blis.bli_id = e->e_id;
+ blis.bli_lock = lock;
+ blis.bli_flag = BLI_DONTFREE;
+
/* safe default */
rs->sr_attrs = op->oq_search.rs_attrs;
rs->sr_operational_attrs = NULL;
rs->sr_ctrls = NULL;
- rs->sr_flags = 0;
+ rs->sr_entry = e;
+ RS_ASSERT( e->e_private != NULL );
+ rs->sr_flags = REP_ENTRY_MUSTRELEASE;
rs->sr_err = LDAP_SUCCESS;
rs->sr_err = send_search_entry( op, rs );
+ rs->sr_attrs = NULL;
+ rs->sr_entry = NULL;
+
+ /* send_search_entry will usually free it.
+ * an overlay might leave its own copy here;
+ * bli_flag will be 0 if lock was already released.
+ */
+ if ( blis.bli_flag ) {
+#ifdef SLAP_ZONE_ALLOC
+ slap_zn_runlock(bdb->bi_cache.c_zctx, e);
+#endif
+ bdb_cache_return_entry_r(bdb, e, &lock);
+ if ( opinfo ) {
+ opinfo->boi_locks = blis.bli_next;
+ } else {
+ LDAP_SLIST_REMOVE( &op->o_extra, &bois.boi_oe,
+ OpExtra, oe_next );
+ }
+ }
+ e = NULL;
switch ( rs->sr_err ) {
case LDAP_SUCCESS: /* entry sent ok */
break;
case LDAP_UNAVAILABLE:
case LDAP_SIZELIMIT_EXCEEDED:
-#ifdef SLAP_ZONE_ALLOC
- slap_zn_runlock(bdb->bi_cache.c_zctx, e);
-#endif
- bdb_cache_return_entry_r(bdb, e, &lock);
- e = NULL;
- rs->sr_entry = NULL;
if ( rs->sr_err == LDAP_SIZELIMIT_EXCEEDED ) {
rs->sr_ref = rs->sr_v2ref;
send_ldap_result( op, rs );
slap_zn_runlock(bdb->bi_cache.c_zctx, e);
#endif
bdb_cache_return_entry_r( bdb, e , &lock );
+ RS_ASSERT( rs->sr_entry == NULL );
e = NULL;
rs->sr_entry = NULL;
}
rs->sr_err = LDAP_SUCCESS;
done:
- if ( !opinfo )
- LOCK_ID_FREE( bdb->bi_dbenv, locker );
-
if( rs->sr_v2ref ) {
ber_bvarray_free( rs->sr_v2ref );
rs->sr_v2ref = NULL;
Operation *op,
SlapReply *rs,
Entry *e,
- BDB_LOCKER locker,
+ DB_TXN *txn,
ID *ids,
ID *scopes )
{
}
if( op->ors_deref & LDAP_DEREF_SEARCHING ) {
- rc = search_aliases( op, rs, e, locker, ids, scopes, stack );
+ rc = search_aliases( op, rs, e, txn, ids, scopes, stack );
} else {
- rc = bdb_dn2idl( op, locker, &e->e_nname, BEI(e), ids, stack );
+ rc = bdb_dn2idl( op, txn, &e->e_nname, BEI(e), ids, stack );
}
if ( rc == LDAP_SUCCESS ) {
- rc = bdb_filter_candidates( op, locker, &f, ids,
+ rc = bdb_filter_candidates( op, txn, &f, ids,
stack, stack+BDB_IDL_UM_SIZE );
}
goto done;
}
+ } else {
+ /* we're going to use ps_cookie */
+ op->o_conn->c_pagedresults_state.ps_cookie = 0;
}
done:;
ID *lastid,
int tentries )
{
- LDAPControl ctrl, *ctrls[2];
+ LDAPControl *ctrls[2];
BerElementBuffer berbuf;
BerElement *ber = (BerElement *)&berbuf;
PagedResultsCookie respcookie;
"send_paged_response: lastid=0x%08lx nentries=%d\n",
lastid ? *lastid : 0, rs->sr_nentries, NULL );
- BER_BVZERO( &ctrl.ldctl_value );
- ctrls[0] = &ctrl;
ctrls[1] = NULL;
ber_init2( ber, NULL, LBER_USE_DER );
/* return size of 0 -- no estimate */
ber_printf( ber, "{iO}", 0, &cookie );
+ ctrls[0] = op->o_tmpalloc( sizeof(LDAPControl), op->o_tmpmemctx );
if ( ber_flatten2( ber, &ctrls[0]->ldctl_value, 0 ) == -1 ) {
goto done;
}
ctrls[0]->ldctl_oid = LDAP_CONTROL_PAGEDRESULTS;
ctrls[0]->ldctl_iscritical = 0;
- rs->sr_ctrls = ctrls;
+ slap_add_ctrls( op, rs, ctrls );
rs->sr_err = LDAP_SUCCESS;
send_ldap_result( op, rs );
- rs->sr_ctrls = NULL;
done:
(void) ber_free_buf( ber );
}
-