/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2000-2008 The OpenLDAP Foundation.
+ * Copyright 2000-2009 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
int
bdb_cache_entry_db_relock(
struct bdb_info *bdb,
- BDB_LOCKER locker,
+ DB_TXN *txn,
EntryInfo *ei,
int rw,
int tryOnly,
list[1].lock = *lock;
list[1].mode = rw ? DB_LOCK_WRITE : DB_LOCK_READ;
list[1].obj = &lockobj;
- rc = bdb->bi_dbenv->lock_vec(bdb->bi_dbenv, BDB_LOCKID(locker), tryOnly ? DB_LOCK_NOWAIT : 0,
+ rc = bdb->bi_dbenv->lock_vec(bdb->bi_dbenv, TXN_ID(txn), tryOnly ? DB_LOCK_NOWAIT : 0,
list, 2, NULL );
if (rc && !tryOnly) {
}
static int
-bdb_cache_entry_db_lock( struct bdb_info *bdb, BDB_LOCKER locker, EntryInfo *ei,
+bdb_cache_entry_db_lock( struct bdb_info *bdb, DB_TXN *txn, EntryInfo *ei,
int rw, int tryOnly, DB_LOCK *lock )
{
#ifdef NO_DB_LOCK
lockobj.data = &ei->bei_id;
lockobj.size = sizeof(ei->bei_id) + 1;
- rc = LOCK_GET(bdb->bi_dbenv, BDB_LOCKID(locker), tryOnly ? DB_LOCK_NOWAIT : 0,
+ rc = LOCK_GET(bdb->bi_dbenv, TXN_ID(txn), tryOnly ? DB_LOCK_NOWAIT : 0,
&lockobj, db_rw, lock);
if (rc && !tryOnly) {
Debug( LDAP_DEBUG_TRACE,
int
bdb_cache_find_ndn(
Operation *op,
- BDB_LOCKER locker,
+ DB_TXN *txn,
struct berval *ndn,
EntryInfo **res )
{
ei.bei_nrdn.bv_val );
lock.mode = DB_LOCK_NG;
- rc = bdb_dn2id( op, &ei.bei_nrdn, &ei, locker, &lock );
+ rc = bdb_dn2id( op, &ei.bei_nrdn, &ei, txn, &lock );
if (rc) {
bdb_cache_entryinfo_lock( eip );
bdb_cache_entry_db_unlock( bdb, &lock );
int
hdb_cache_find_parent(
Operation *op,
- BDB_LOCKER locker,
+ DB_TXN *txn,
ID id,
EntryInfo **res )
{
ei.bei_ckids = 0;
for (;;) {
- rc = hdb_dn2id_parent( op, locker, &ei, &eip.bei_id );
+ rc = hdb_dn2id_parent( op, txn, &ei, &eip.bei_id );
if ( rc ) break;
/* Save the previous node, if any */
DB_LOCK lock, *lockp;
EntryInfo *elru, *elnext = NULL;
int count, islocked, eimax;
+ int efree = 0, eifree = 0, eicount, ecount;
+#ifdef LDAP_DEBUG
+ int iter;
+#endif
/* Wait for the mutex; we're the only one trying to purge. */
ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_lru_mutex );
- if ( bdb->bi_cache.c_cursize <= bdb->bi_cache.c_maxsize ) {
+ /* maximum number of EntryInfo leaves to cache. In slapcat
+ * we always free all leaf nodes.
+ */
+ if ( slapMode & SLAP_TOOL_READONLY )
+ eimax = 0;
+ else
+ eimax = bdb->bi_cache.c_eimax;
+
+ if ( bdb->bi_cache.c_cursize > bdb->bi_cache.c_maxsize )
+ efree = bdb->bi_cache.c_minfree;
+ if ( bdb->bi_cache.c_leaves > eimax ) {
+ eifree = bdb->bi_cache.c_minfree * 10;
+ if ( eifree >= eimax )
+ eifree = eimax / 2;
+ }
+
+ if ( !efree && !eifree ) {
ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_lru_mutex );
bdb->bi_cache.c_purging = 0;
return;
}
- if ( bdb->bi_cache.c_locker ) {
+ if ( bdb->bi_cache.c_txn ) {
lockp = &lock;
} else {
lockp = NULL;
}
count = 0;
-
- /* maximum number of EntryInfo leaves to cache. In slapcat
- * we always free all leaf nodes.
- */
- if ( slapMode & SLAP_TOOL_READONLY )
- eimax = 0;
- else
- eimax = bdb->bi_cache.c_eimax;
+ eicount = 0;
+ ecount = 0;
+#ifdef LDAP_DEBUG
+ iter = 0;
+#endif
/* Look for an unused entry to remove */
for ( elru = bdb->bi_cache.c_lruhead; elru; elru = elnext ) {
* the object is idle.
*/
if ( bdb_cache_entry_db_lock( bdb,
- bdb->bi_cache.c_locker, elru, 1, 1, lockp ) == 0 ) {
+ bdb->bi_cache.c_txn, elru, 1, 1, lockp ) == 0 ) {
/* Free entry for this node if it's present */
if ( elru->bei_e ) {
- elru->bei_e->e_private = NULL;
+ ecount++;
+ if ( count < efree ) {
+ elru->bei_e->e_private = NULL;
#ifdef SLAP_ZONE_ALLOC
- bdb_entry_return( bdb, elru->bei_e, elru->bei_zseq );
+ bdb_entry_return( bdb, elru->bei_e, elru->bei_zseq );
#else
- bdb_entry_return( elru->bei_e );
+ bdb_entry_return( elru->bei_e );
#endif
- elru->bei_e = NULL;
- count++;
+ elru->bei_e = NULL;
+ count++;
+ } else {
+ /* Keep this node cached, skip to next */
+ bdb_cache_entry_db_unlock( bdb, lockp );
+ goto next;
+ }
}
bdb_cache_entry_db_unlock( bdb, lockp );
if ( elru->bei_kids ) {
/* Drop from list, we ignore it... */
LRU_DEL( &bdb->bi_cache, elru );
- } else if ( bdb->bi_cache.c_leaves > eimax ) {
+ } else if ( eicount < eifree ) {
/* Too many leaf nodes, free this one */
bdb_cache_delete_internal( &bdb->bi_cache, elru, 0 );
bdb_cache_delete_cleanup( &bdb->bi_cache, elru );
islocked = 0;
+ eicount++;
} /* Leave on list until we need to free it */
}
+next:
if ( islocked )
bdb_cache_entryinfo_unlock( elru );
- if ( count >= bdb->bi_cache.c_minfree ) {
- ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_count_mutex );
- bdb->bi_cache.c_cursize -= count;
- ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_count_mutex );
+ if ( count >= efree && eicount >= eifree ) {
+ if ( count || ecount > bdb->bi_cache.c_cursize ) {
+ ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_count_mutex );
+ /* HACK: we seem to be losing track, fix up now */
+ if ( ecount > bdb->bi_cache.c_cursize )
+ bdb->bi_cache.c_cursize = ecount;
+ bdb->bi_cache.c_cursize -= count;
+ ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_count_mutex );
+ }
break;
}
bottom:
if ( elnext == bdb->bi_cache.c_lruhead )
break;
+#ifdef LDAP_DEBUG
+ iter++;
+#endif
}
bdb->bi_cache.c_lruhead = elnext;
ID id,
EntryInfo **eip,
int flag,
- BDB_LOCKER locker,
DB_LOCK *lock )
{
struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
/* See if the ID exists in the database; add it to the cache if so */
if ( !*eip ) {
#ifndef BDB_HIER
- rc = bdb_id2entry( op->o_bd, tid, locker, id, &ep );
+ rc = bdb_id2entry( op->o_bd, tid, id, &ep );
if ( rc == 0 ) {
- rc = bdb_cache_find_ndn( op, locker,
+ rc = bdb_cache_find_ndn( op, tid,
&ep->e_nname, eip );
if ( *eip ) flag |= ID_LOCKED;
if ( rc ) {
}
}
#else
- rc = hdb_cache_find_parent(op, locker, id, eip );
+ rc = hdb_cache_find_parent(op, tid, id, eip );
if ( rc == 0 ) flag |= ID_LOCKED;
#endif
}
bdb_cache_entryinfo_unlock( *eip );
flag ^= ID_LOCKED;
}
- rc = bdb_cache_entry_db_lock( bdb, locker, *eip, load, 0, lock );
+ rc = bdb_cache_entry_db_lock( bdb, tid, *eip, load, 0, lock );
if ( (*eip)->bei_state & CACHE_ENTRY_DELETED ) {
rc = DB_NOTFOUND;
bdb_cache_entry_db_unlock( bdb, lock );
} else if ( rc == 0 ) {
if ( load ) {
if ( !ep) {
- rc = bdb_id2entry( op->o_bd, tid, locker, id, &ep );
+ rc = bdb_id2entry( op->o_bd, tid, id, &ep );
}
if ( rc == 0 ) {
ep->e_private = *eip;
if (( flag & ID_NOCACHE ) &&
( bdb_cache_entryinfo_trylock( *eip ) == 0 )) {
/* Set the cached state only if no other thread
- * found the info while we was loading the entry.
+ * found the info while we were loading the entry.
*/
if ( (*eip)->bei_finders == 1 )
(*eip)->bei_state |= CACHE_ENTRY_NOT_CACHED;
}
if ( rc == 0 ) {
/* If we succeeded, downgrade back to a readlock. */
- rc = bdb_cache_entry_db_relock( bdb, locker,
+ rc = bdb_cache_entry_db_relock( bdb, tid,
*eip, 0, 0, lock );
} else {
/* Otherwise, release the lock. */
rc = bdb_fix_dn( (*eip)->bei_e, 1 );
if ( rc ) {
bdb_cache_entry_db_relock( bdb,
- locker, *eip, 1, 0, lock );
+ tid, *eip, 1, 0, lock );
/* check again in case other modifier did it already */
if ( bdb_fix_dn( (*eip)->bei_e, 1 ) )
rc = bdb_fix_dn( (*eip)->bei_e, 2 );
bdb_cache_entry_db_relock( bdb,
- locker, *eip, 0, 0, lock );
+ tid, *eip, 0, 0, lock );
}
#endif
}
- bdb_cache_entryinfo_lock( *eip );
- (*eip)->bei_finders--;
- if ( load )
- (*eip)->bei_state ^= CACHE_ENTRY_LOADING;
- bdb_cache_entryinfo_unlock( *eip );
}
+ bdb_cache_entryinfo_lock( *eip );
+ (*eip)->bei_finders--;
+ if ( load )
+ (*eip)->bei_state ^= CACHE_ENTRY_LOADING;
+ bdb_cache_entryinfo_unlock( *eip );
}
}
if ( flag & ID_LOCKED ) {
int purge = 0;
if ( load ) {
+ ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_count_mutex );
if ( !( flag & ID_NOCACHE )) {
- ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_count_mutex );
bdb->bi_cache.c_cursize++;
if ( bdb->bi_cache.c_cursize > bdb->bi_cache.c_maxsize &&
!bdb->bi_cache.c_purging ) {
purge = 1;
bdb->bi_cache.c_purging = 1;
}
- ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_count_mutex );
+ } else if ( bdb->bi_cache.c_leaves > bdb->bi_cache.c_eimax && !bdb->bi_cache.c_purging ) {
+ purge = 1;
+ bdb->bi_cache.c_purging = 1;
}
+ ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_count_mutex );
}
if ( purge )
bdb_cache_lru_purge( bdb );
EntryInfo *eip,
Entry *e,
struct berval *nrdn,
- BDB_LOCKER locker,
+ DB_TXN *txn,
DB_LOCK *lock )
{
EntryInfo *new, ei;
/* Lock this entry so that bdb_add can run to completion.
* It can only fail if BDB has run out of lock resources.
*/
- rc = bdb_cache_entry_db_lock( bdb, locker, &ei, 0, 0, lock );
+ rc = bdb_cache_entry_db_lock( bdb, txn, &ei, 0, 0, lock );
if ( rc ) {
bdb_cache_entryinfo_unlock( eip );
return rc;
struct bdb_info *bdb,
Entry *e,
Attribute *newAttrs,
- BDB_LOCKER locker,
+ DB_TXN *txn,
DB_LOCK *lock )
{
EntryInfo *ei = BEI(e);
int rc;
/* Get write lock on data */
- rc = bdb_cache_entry_db_relock( bdb, locker, ei, 1, 0, lock );
+ rc = bdb_cache_entry_db_relock( bdb, txn, ei, 1, 0, lock );
/* If we've done repeated mods on a cached entry, then e_attrs
* is no longer contiguous with the entry, and must be freed.
struct berval *nrdn,
Entry *new,
EntryInfo *ein,
- BDB_LOCKER locker,
+ DB_TXN *txn,
DB_LOCK *lock )
{
EntryInfo *ei = BEI(e), *pei;
#endif
/* Get write lock on data */
- rc = bdb_cache_entry_db_relock( bdb, locker, ei, 1, 0, lock );
+ rc = bdb_cache_entry_db_relock( bdb, txn, ei, 1, 0, lock );
if ( rc ) return rc;
/* If we've done repeated mods on a cached entry, then e_attrs
bdb_cache_delete(
struct bdb_info *bdb,
Entry *e,
- BDB_LOCKER locker,
+ DB_TXN *txn,
DB_LOCK *lock )
{
EntryInfo *ei = BEI(e);
assert( e->e_private != NULL );
+ /* Lock the entry's info */
+ bdb_cache_entryinfo_lock( ei );
+
/* Set this early, warn off any queriers */
ei->bei_state |= CACHE_ENTRY_DELETED;
- /* Lock the entry's info */
- bdb_cache_entryinfo_lock( ei );
+ bdb_cache_entryinfo_unlock( ei );
/* Get write lock on the data */
- rc = bdb_cache_entry_db_relock( bdb, locker, ei, 1, 0, lock );
+ rc = bdb_cache_entry_db_relock( bdb, txn, ei, 1, 0, lock );
if ( rc ) {
/* couldn't lock, undo and give up */
ei->bei_state ^= CACHE_ENTRY_DELETED;
- bdb_cache_entryinfo_unlock( ei );
return rc;
}
/* free lru mutex */
ldap_pvt_thread_mutex_unlock( &bdb->bi_cache.c_lru_mutex );
- /* Leave entry info locked */
-
return( rc );
}
Cache *cache,
EntryInfo *ei )
{
+ /* Enter with ei locked */
+
if ( ei->bei_e ) {
ei->bei_e->e_private = NULL;
#ifdef SLAP_ZONE_ALLOC
#endif
#endif
-#ifdef BDB_REUSE_LOCKERS
static void
-bdb_locker_id_free( void *key, void *data )
+bdb_reader_free( void *key, void *data )
{
- DB_ENV *env = key;
- u_int32_t lockid;
- int rc;
+ /* DB_ENV *env = key; */
+ DB_TXN *txn = data;
-#if DB_VERSION_FULL >= 0x04060012
- BDB_LOCKER lptr = data;
- lockid = lptr->id;
-#else
- lockid = (long)data;
-#endif
- rc = XLOCK_ID_FREE( env, lockid );
- if ( rc == EINVAL ) {
- DB_LOCKREQ lr;
- Debug( LDAP_DEBUG_ANY,
- "bdb_locker_id_free: %lu err %s(%d)\n",
- (unsigned long) lockid, db_strerror(rc), rc );
- /* release all locks held by this locker. */
- lr.op = DB_LOCK_PUT_ALL;
- lr.obj = NULL;
- env->lock_vec( env, lockid, 0, &lr, 1, NULL );
- XLOCK_ID_FREE( env, lockid );
- }
+ TXN_ABORT( txn );
}
/* free up any keys used by the main thread */
void
-bdb_locker_flush( DB_ENV *env )
+bdb_reader_flush( DB_ENV *env )
{
void *data;
void *ctx = ldap_pvt_thread_pool_context();
if ( !ldap_pvt_thread_pool_getkey( ctx, env, &data, NULL ) ) {
ldap_pvt_thread_pool_setkey( ctx, env, NULL, 0, NULL, NULL );
- bdb_locker_id_free( env, data );
+ bdb_reader_free( env, data );
}
}
int
-bdb_locker_id( Operation *op, DB_ENV *env, BDB_LOCKER *locker )
+bdb_reader_get( Operation *op, DB_ENV *env, DB_TXN **txn )
{
int i, rc;
- u_int32_t lockid;
void *data;
void *ctx;
- if ( !env || !locker ) return -1;
+ if ( !env || !txn ) return -1;
/* If no op was provided, try to find the ctx anyway... */
if ( op ) {
/* Shouldn't happen unless we're single-threaded */
if ( !ctx ) {
- *locker = 0;
+ *txn = NULL;
return 0;
}
if ( ldap_pvt_thread_pool_getkey( ctx, env, &data, NULL ) ) {
for ( i=0, rc=1; rc != 0 && i<4; i++ ) {
- rc = XLOCK_ID( env, &lockid );
+ rc = TXN_BEGIN( env, NULL, txn, DB_READ_COMMITTED );
if (rc) ldap_pvt_thread_yield();
}
if ( rc != 0) {
return rc;
}
-#if DB_VERSION_FULL >= 0x04060012
- { BDB_LOCKER lptr;
- __lock_getlocker( env->lk_handle, lockid, 0, &lptr );
- data = lptr;
- }
-#else
- data = (void *)((long)lockid);
-#endif
+ data = *txn;
if ( ( rc = ldap_pvt_thread_pool_setkey( ctx, env,
- data, bdb_locker_id_free, NULL, NULL ) ) ) {
- XLOCK_ID_FREE( env, lockid );
- Debug( LDAP_DEBUG_ANY, "bdb_locker_id: err %s(%d)\n",
+ data, bdb_reader_free, NULL, NULL ) ) ) {
+ TXN_ABORT( *txn );
+ Debug( LDAP_DEBUG_ANY, "bdb_reader_get: err %s(%d)\n",
db_strerror(rc), rc, 0 );
return rc;
}
} else {
- lockid = (long)data;
+ *txn = data;
}
-#if DB_VERSION_FULL >= 0x04060012
- *locker = data;
-#else
- *locker = lockid;
-#endif
return 0;
}
-#endif /* BDB_REUSE_LOCKERS */
projects / openldap / blobdiff