static int bdb_db_open( BackendDB *be, ConfigReply *cr ) { int rc, i; struct bdb_info *bdb = (struct bdb_info *) be->be_private; struct stat stat1, stat2; u_int32_t flags; char path[MAXPATHLEN]; char *dbhome; Entry *e = NULL; int do_recover = 0, do_alock_recover = 0; int alockt, quick = 0; int do_retry = 1; if ( be->be_suffix == NULL ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": need suffix.\n", 1, 0, 0 ); return -1; } Debug( LDAP_DEBUG_ARGS, LDAP_XSTRING(bdb_db_open) ": \"%s\"\n", be->be_suffix[0].bv_val, 0, 0 ); /* Check existence of dbenv_home. Any error means trouble */ rc = stat( bdb->bi_dbenv_home, &stat1 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "cannot access database directory \"%s\" (%d).\n", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, errno ); return -1; } /* Perform database use arbitration/recovery logic */ alockt = (slapMode & SLAP_TOOL_READONLY) ? ALOCK_LOCKED : ALOCK_UNIQUE; if ( slapMode & SLAP_TOOL_QUICK ) { alockt |= ALOCK_NOSAVE; quick = 1; } rc = alock_open( &bdb->bi_alock_info, "slapd", bdb->bi_dbenv_home, alockt ); /* alockt is TRUE if the existing environment was created in Quick mode */ alockt = (rc & ALOCK_NOSAVE) ? 1 : 0; rc &= ~ALOCK_NOSAVE; if( rc == ALOCK_RECOVER ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "unclean shutdown detected; attempting recovery.\n", be->be_suffix[0].bv_val, 0, 0 ); do_alock_recover = 1; do_recover = DB_RECOVER; } else if( rc == ALOCK_BUSY ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "database already in use.\n", be->be_suffix[0].bv_val, 0, 0 ); return -1; } else if( rc != ALOCK_CLEAN ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "alock package is unstable.\n", be->be_suffix[0].bv_val, 0, 0 ); return -1; } if ( rc == ALOCK_CLEAN ) be->be_flags |= SLAP_DBFLAG_CLEAN; /* * The DB_CONFIG file may have changed. If so, recover the * database so that new settings are put into effect. Also * note the possible absence of DB_CONFIG in the log. */ if( stat( bdb->bi_db_config_path, &stat1 ) == 0 ) { if ( !do_recover ) { char *ptr = lutil_strcopy(path, bdb->bi_dbenv_home); *ptr++ = LDAP_DIRSEP[0]; strcpy( ptr, "__db.001" ); if( stat( path, &stat2 ) == 0 ) { if( stat2.st_mtime < stat1.st_mtime ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": DB_CONFIG for suffix \"%s\" has changed.\n", be->be_suffix[0].bv_val, 0, 0 ); if ( quick ) { Debug( LDAP_DEBUG_ANY, "Cannot use Quick mode; perform manual recovery first.\n", 0, 0, 0 ); slapMode ^= SLAP_TOOL_QUICK; rc = -1; goto fail; } else { Debug( LDAP_DEBUG_ANY, "Performing database recovery to activate new settings.\n", 0, 0, 0 ); } do_recover = DB_RECOVER; } } } } else { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": warning - no DB_CONFIG file found " "in directory %s: (%d).\n" "Expect poor performance for suffix \"%s\".\n", bdb->bi_dbenv_home, errno, be->be_suffix[0].bv_val ); } /* Always let slapcat run, regardless of environment state. * This can be used to cause a cache flush after an unclean * shutdown. */ if ( do_recover && ( slapMode & SLAP_TOOL_READONLY )) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "recovery skipped in read-only mode. " "Run manual recovery if errors are encountered.\n", be->be_suffix[0].bv_val, 0, 0 ); do_recover = 0; do_alock_recover = 0; quick = alockt; } /* An existing environment in Quick mode has nothing to recover. */ if ( alockt && do_recover ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "cannot recover, database must be reinitialized.\n", be->be_suffix[0].bv_val, 0, 0 ); rc = -1; goto fail; } rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "db_env_create failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } #ifdef HAVE_EBCDIC strcpy( path, bdb->bi_dbenv_home ); __atoe( path ); dbhome = path; #else dbhome = bdb->bi_dbenv_home; #endif /* If existing environment is clean but doesn't support * currently requested modes, remove it. */ if ( !do_recover && ( alockt ^ quick )) { shm_retry: rc = bdb->bi_dbenv->remove( bdb->bi_dbenv, dbhome, DB_FORCE ); if ( rc ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv remove failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); bdb->bi_dbenv = NULL; goto fail; } rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "db_env_create failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv, be->be_suffix[0].bv_val ); bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall ); bdb->bi_dbenv->set_lk_detect( bdb->bi_dbenv, bdb->bi_lock_detect ); if ( !BER_BVISNULL( &bdb->bi_db_crypt_key )) { rc = bdb->bi_dbenv->set_encrypt( bdb->bi_dbenv, bdb->bi_db_crypt_key.bv_val, DB_ENCRYPT_AES ); if ( rc ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv set_encrypt failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } /* One long-lived TXN per thread, two TXNs per write op */ bdb->bi_dbenv->set_tx_max( bdb->bi_dbenv, connection_pool_max * 3 ); if( bdb->bi_dbenv_xflags != 0 ) { rc = bdb->bi_dbenv->set_flags( bdb->bi_dbenv, bdb->bi_dbenv_xflags, 1); if( rc != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv_set_flags failed: %s (%d).\n", be->be_suffix[0].bv_val, db_strerror(rc), rc ); goto fail; } } #define BDB_TXN_FLAGS (DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN) Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "dbenv_open(%s).\n", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, 0); flags = DB_INIT_MPOOL | DB_CREATE | DB_THREAD; if ( !quick ) flags |= BDB_TXN_FLAGS; /* If a key was set, use shared memory for the BDB environment */ if ( bdb->bi_shm_key ) { bdb->bi_dbenv->set_shm_key( bdb->bi_dbenv, bdb->bi_shm_key ); flags |= DB_SYSTEM_MEM; } rc = (bdb->bi_dbenv->open)( bdb->bi_dbenv, dbhome, flags | do_recover, bdb->bi_dbenv_mode ); if ( rc ) { /* Regular open failed, probably a missing shm environment. * Start over, do a recovery. */ if ( !do_recover && bdb->bi_shm_key && do_retry ) { bdb->bi_dbenv->close( bdb->bi_dbenv, 0 ); rc = db_env_create( &bdb->bi_dbenv, 0 ); if( rc == 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": " "shared memory env open failed, assuming stale env.\n", be->be_suffix[0].bv_val, 0, 0 ); do_retry = 0; goto shm_retry; } } Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\" cannot be %s, err %d. " "Restore from backup!\n", be->be_suffix[0].bv_val, do_recover ? "recovered" : "opened", rc ); goto fail; } if ( do_alock_recover && alock_recover (&bdb->bi_alock_info) != 0 ) { Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": database \"%s\": alock_recover failed\n", be->be_suffix[0].bv_val, 0, 0 ); rc = -1; goto fail; } #ifdef SLAP_ZONE_ALLOC if ( bdb->bi_cache.c_maxsize ) { bdb->bi_cache.c_zctx = slap_zn_mem_create( SLAP_ZONE_INITSIZE, SLAP_ZONE_MAXSIZE, SLAP_ZONE_DELTA, SLAP_ZONE_SIZE); } #endif /* dncache defaults to 0 == unlimited * must be >= entrycache */ if ( bdb->bi_cache.c_eimax && bdb->bi_cache.c_eimax < bdb->bi_cache.c_maxsize ) { bdb->bi_cache.c_eimax = bdb->bi_cache.c_maxsize; } if ( bdb->bi_idl_cache_max_size ) { bdb->bi_idl_tree = NULL; bdb->bi_idl_cache_size = 0; } flags = DB_THREAD | bdb->bi_db_opflags; #ifdef DB_AUTO_COMMIT if ( !quick ) flags |= DB_AUTO_COMMIT; #endif bdb->bi_databases = (struct bdb_db_info **) ch_malloc( BDB_INDICES * sizeof(struct bdb_db_info *) ); /* open (and create) main database */ for( i = 0; bdbi_databases[i].name.bv_val; i++ ) { struct bdb_db_info *db; db = (struct bdb_db_info *) ch_calloc(1, sizeof(struct bdb_db_info)); rc = db_create( &db->bdi_db, bdb->bi_dbenv, 0 ); if( rc != 0 ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db_create(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } if( !BER_BVISNULL( &bdb->bi_db_crypt_key )) { rc = db->bdi_db->set_flags( db->bdi_db, DB_ENCRYPT ); if ( rc ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db set_flags(DB_ENCRYPT)(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } } if( bdb->bi_flags & BDB_CHKSUM ) { rc = db->bdi_db->set_flags( db->bdi_db, DB_CHKSUM ); if ( rc ) { snprintf(cr->msg, sizeof(cr->msg), "database \"%s\": db set_flags(DB_CHKSUM)(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } } rc = bdb_db_findsize( bdb, (struct berval *)&bdbi_databases[i].name ); if( i == BDB_ID2ENTRY ) { if ( !rc ) rc = BDB_ID2ENTRY_PAGESIZE; rc = db->bdi_db->set_pagesize( db->bdi_db, rc ); if ( slapMode & SLAP_TOOL_MODE ) db->bdi_db->mpf->set_priority( db->bdi_db->mpf, DB_PRIORITY_VERY_LOW ); if ( slapMode & SLAP_TOOL_READMAIN ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } } else { /* Use FS default size if not configured */ if ( rc ) rc = db->bdi_db->set_pagesize( db->bdi_db, rc ); rc = db->bdi_db->set_flags( db->bdi_db, DB_DUP | DB_DUPSORT ); #ifndef BDB_HIER if ( slapMode & SLAP_TOOL_READONLY ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } #else rc = db->bdi_db->set_dup_compare( db->bdi_db, bdb_dup_compare ); if ( slapMode & (SLAP_TOOL_READONLY|SLAP_TOOL_READMAIN) ) { flags |= DB_RDONLY; } else { flags |= DB_CREATE; } #endif } #ifdef HAVE_EBCDIC strcpy( path, bdbi_databases[i].file ); __atoe( path ); rc = DB_OPEN( db->bdi_db, path, /* bdbi_databases[i].name, */ NULL, bdbi_databases[i].type, bdbi_databases[i].flags | flags, bdb->bi_dbenv_mode ); #else rc = DB_OPEN( db->bdi_db, bdbi_databases[i].file, /* bdbi_databases[i].name, */ NULL, bdbi_databases[i].type, bdbi_databases[i].flags | flags, bdb->bi_dbenv_mode ); #endif if ( rc != 0 ) { snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": " "db_open(%s/%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, bdbi_databases[i].file, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); db->bdi_db->close( db->bdi_db, 0 ); goto fail; } flags &= ~(DB_CREATE | DB_RDONLY); db->bdi_name = bdbi_databases[i].name; bdb->bi_databases[i] = db; } bdb->bi_databases[i] = NULL; bdb->bi_ndatabases = i; /* get nextid */ rc = bdb_last_id( be, NULL ); if( rc != 0 ) { snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": " "last_id(%s) failed: %s (%d).", be->be_suffix[0].bv_val, bdb->bi_dbenv_home, db_strerror(rc), rc ); Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open) ": %s\n", cr->msg, 0, 0 ); goto fail; } if ( !quick ) { TXN_BEGIN(bdb->bi_dbenv, NULL, &bdb->bi_cache.c_txn, DB_READ_COMMITTED | DB_TXN_NOWAIT); } entry_prealloc( bdb->bi_cache.c_maxsize ); attr_prealloc( bdb->bi_cache.c_maxsize * 20 ); /* setup for empty-DN contexts */ if ( BER_BVISEMPTY( &be->be_nsuffix[0] )) { rc = bdb_id2entry( be, NULL, 0, &e ); } if ( !e ) { struct berval gluebv = BER_BVC("glue"); Operation op = {0}; Opheader ohdr = {0}; e = entry_alloc(); e->e_id = 0; ber_dupbv( &e->e_name, (struct berval *)&slap_empty_bv ); ber_dupbv( &e->e_nname, (struct berval *)&slap_empty_bv ); attr_merge_one( e, slap_schema.si_ad_objectClass, &gluebv, NULL ); attr_merge_one( e, slap_schema.si_ad_structuralObjectClass, &gluebv, NULL ); op.o_hdr = &ohdr; op.o_bd = be; op.ora_e = e; op.o_dn = be->be_rootdn; op.o_ndn = be->be_rootndn; slap_add_opattrs( &op, NULL, NULL, 0, 0 ); } e->e_ocflags = SLAP_OC_GLUE|SLAP_OC__END; e->e_private = &bdb->bi_cache.c_dntree; bdb->bi_cache.c_dntree.bei_e = e; /* monitor setup */ rc = bdb_monitor_db_open( be ); if ( rc != 0 ) { goto fail; } bdb->bi_flags |= BDB_IS_OPEN; return 0; fail: bdb_db_close( be, NULL ); return rc; }
int bdb_cache_find_id( Operation *op, DB_TXN *tid, ID id, EntryInfo **eip, int flag, DB_LOCK *lock ) { struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private; Entry *ep = NULL; int rc = 0, load = 0; EntryInfo ei = { 0 }; ei.bei_id = id; #ifdef SLAP_ZONE_ALLOC slap_zh_rlock(bdb->bi_cache.c_zctx); #endif /* If we weren't given any info, see if we have it already cached */ if ( !*eip ) { again: ldap_pvt_thread_rdwr_rlock( &bdb->bi_cache.c_rwlock ); *eip = (EntryInfo *) avl_find( bdb->bi_cache.c_idtree, (caddr_t) &ei, bdb_id_cmp ); if ( *eip ) { /* If the lock attempt fails, the info is in use */ if ( bdb_cache_entryinfo_trylock( *eip )) { int del = (*eip)->bei_state & CACHE_ENTRY_DELETED; ldap_pvt_thread_rdwr_runlock( &bdb->bi_cache.c_rwlock ); /* If this node is being deleted, treat * as if the delete has already finished */ if ( del ) { return DB_NOTFOUND; } /* otherwise, wait for the info to free up */ ldap_pvt_thread_yield(); goto again; } /* If this info isn't hooked up to its parent yet, * unlock and wait for it to be fully initialized */ if ( (*eip)->bei_state & CACHE_ENTRY_NOT_LINKED ) { bdb_cache_entryinfo_unlock( *eip ); ldap_pvt_thread_rdwr_runlock( &bdb->bi_cache.c_rwlock ); ldap_pvt_thread_yield(); goto again; } flag |= ID_LOCKED; } ldap_pvt_thread_rdwr_runlock( &bdb->bi_cache.c_rwlock ); } /* 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, id, &ep ); if ( rc == 0 ) { rc = bdb_cache_find_ndn( op, tid, &ep->e_nname, eip ); if ( *eip ) flag |= ID_LOCKED; if ( rc ) { ep->e_private = NULL; #ifdef SLAP_ZONE_ALLOC bdb_entry_return( bdb, ep, (*eip)->bei_zseq ); #else bdb_entry_return( ep ); #endif ep = NULL; } } #else rc = hdb_cache_find_parent(op, tid, id, eip ); if ( rc == 0 ) flag |= ID_LOCKED; #endif } /* Ok, we found the info, do we have the entry? */ if ( rc == 0 ) { if ( !( flag & ID_LOCKED )) { bdb_cache_entryinfo_lock( *eip ); flag |= ID_LOCKED; } if ( (*eip)->bei_state & CACHE_ENTRY_DELETED ) { rc = DB_NOTFOUND; } else { (*eip)->bei_finders++; (*eip)->bei_state |= CACHE_ENTRY_REFERENCED; if ( flag & ID_NOENTRY ) { bdb_cache_entryinfo_unlock( *eip ); return 0; } /* Make sure only one thread tries to load the entry */ load1: #ifdef SLAP_ZONE_ALLOC if ((*eip)->bei_e && !slap_zn_validate( bdb->bi_cache.c_zctx, (*eip)->bei_e, (*eip)->bei_zseq)) { (*eip)->bei_e = NULL; (*eip)->bei_zseq = 0; } #endif if ( !(*eip)->bei_e && !((*eip)->bei_state & CACHE_ENTRY_LOADING)) { load = 1; (*eip)->bei_state |= CACHE_ENTRY_LOADING; flag |= ID_CHKPURGE; } if ( !load ) { /* Clear the uncached state if we are not * loading it, i.e it is already cached or * another thread is currently loading it. */ if ( (*eip)->bei_state & CACHE_ENTRY_NOT_CACHED ) { (*eip)->bei_state ^= CACHE_ENTRY_NOT_CACHED; flag |= ID_CHKPURGE; } } if ( flag & ID_LOCKED ) { bdb_cache_entryinfo_unlock( *eip ); flag ^= ID_LOCKED; } 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 ); bdb_cache_entryinfo_lock( *eip ); (*eip)->bei_finders--; bdb_cache_entryinfo_unlock( *eip ); } else if ( rc == 0 ) { if ( load ) { if ( !ep) { rc = bdb_id2entry( op->o_bd, tid, id, &ep ); } if ( rc == 0 ) { ep->e_private = *eip; #ifdef BDB_HIER while ( (*eip)->bei_state & CACHE_ENTRY_NOT_LINKED ) ldap_pvt_thread_yield(); bdb_fix_dn( ep, 0 ); #endif bdb_cache_entryinfo_lock( *eip ); (*eip)->bei_e = ep; #ifdef SLAP_ZONE_ALLOC (*eip)->bei_zseq = *((ber_len_t *)ep - 2); #endif ep = NULL; if ( flag & ID_NOCACHE ) { /* Set the cached state only if no other thread * found the info while we were loading the entry. */ if ( (*eip)->bei_finders == 1 ) { (*eip)->bei_state |= CACHE_ENTRY_NOT_CACHED; flag ^= ID_CHKPURGE; } } bdb_cache_entryinfo_unlock( *eip ); bdb_cache_lru_link( bdb, *eip ); } if ( rc == 0 ) { /* If we succeeded, downgrade back to a readlock. */ rc = bdb_cache_entry_db_relock( bdb, tid, *eip, 0, 0, lock ); } else { /* Otherwise, release the lock. */ bdb_cache_entry_db_unlock( bdb, lock ); } } else if ( !(*eip)->bei_e ) { /* Some other thread is trying to load the entry, * wait for it to finish. */ bdb_cache_entry_db_unlock( bdb, lock ); bdb_cache_entryinfo_lock( *eip ); flag |= ID_LOCKED; goto load1; #ifdef BDB_HIER } else { /* Check for subtree renames */ rc = bdb_fix_dn( (*eip)->bei_e, 1 ); if ( rc ) { bdb_cache_entry_db_relock( bdb, 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, 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 ); } } } if ( flag & ID_LOCKED ) { bdb_cache_entryinfo_unlock( *eip ); } if ( ep ) { ep->e_private = NULL; #ifdef SLAP_ZONE_ALLOC bdb_entry_return( bdb, ep, (*eip)->bei_zseq ); #else bdb_entry_return( ep ); #endif } if ( rc == 0 ) { int purge = 0; if (( flag & ID_CHKPURGE ) || bdb->bi_cache.c_eimax ) { ldap_pvt_thread_mutex_lock( &bdb->bi_cache.c_count_mutex ); if ( flag & ID_CHKPURGE ) { bdb->bi_cache.c_cursize++; if ( !bdb->bi_cache.c_purging && bdb->bi_cache.c_cursize > bdb->bi_cache.c_maxsize ) { purge = 1; bdb->bi_cache.c_purging = 1; } } else if ( !bdb->bi_cache.c_purging && bdb->bi_cache.c_eimax && bdb->bi_cache.c_leaves > bdb->bi_cache.c_eimax ) { 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 ); } #ifdef SLAP_ZONE_ALLOC if (rc == 0 && (*eip)->bei_e) { slap_zn_rlock(bdb->bi_cache.c_zctx, (*eip)->bei_e); } slap_zh_runlock(bdb->bi_cache.c_zctx); #endif return rc; }