int bdb_tool_entry_open(
BackendDB *be, int mode )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
/* initialize key and data thangs */
DBTzero( &key );
DBTzero( &data );
key.flags = DB_DBT_USERMEM;
key.data = &nid;
key.size = key.ulen = sizeof( nid );
data.flags = DB_DBT_USERMEM;
if (cursor == NULL) {
int rc = bdb->bi_id2entry->bdi_db->cursor(
bdb->bi_id2entry->bdi_db, bdb->bi_cache.c_txn, &cursor,
bdb->bi_db_opflags );
if( rc != 0 ) {
return -1;
}
}
/* Set up for threaded slapindex */
if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) {
if ( !bdb_tool_info ) {
#ifdef USE_TRICKLE
ldap_pvt_thread_mutex_init( &bdb_tool_trickle_mutex );
ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond );
ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond_end );
ldap_pvt_thread_pool_submit( &connection_pool, bdb_tool_trickle_task, bdb->bi_dbenv );
#endif
ldap_pvt_thread_mutex_init( &bdb_tool_index_mutex );
ldap_pvt_thread_cond_init( &bdb_tool_index_cond_main );
ldap_pvt_thread_cond_init( &bdb_tool_index_cond_work );
if ( bdb->bi_nattrs ) {
int i;
bdb_tool_threads = slap_tool_thread_max - 1;
if ( bdb_tool_threads > 1 ) {
bdb_tool_index_threads = ch_malloc( bdb_tool_threads * sizeof( int ));
bdb_tool_index_rec = ch_malloc( bdb->bi_nattrs * sizeof( IndexRec ));
bdb_tool_index_tcount = bdb_tool_threads - 1;
for (i=1; i<bdb_tool_threads; i++) {
int *ptr = ch_malloc( sizeof( int ));
*ptr = i;
ldap_pvt_thread_pool_submit( &connection_pool,
bdb_tool_index_task, ptr );
}
}
}
bdb_tool_info = bdb;
}
}
return 0;
}
/*
* shutdown all connections
*/
int connections_shutdown(void)
{
ber_socket_t i;
for ( i = 0; i < dtblsize; i++ ) {
if( connections[i].c_struct_state != SLAP_C_UNINITIALIZED ) {
ldap_pvt_thread_mutex_lock( &connections[i].c_mutex );
if( connections[i].c_struct_state == SLAP_C_USED ) {
/* give persistent clients a chance to cleanup */
if( connections[i].c_conn_state == SLAP_C_CLIENT ) {
ldap_pvt_thread_pool_submit( &connection_pool,
connections[i].c_clientfunc, connections[i].c_clientarg );
} else {
/* c_mutex is locked */
connection_closing( &connections[i], "slapd shutdown" );
connection_close( &connections[i] );
}
}
ldap_pvt_thread_mutex_unlock( &connections[i].c_mutex );
}
}
return 0;
}
static int
autoca_setca( struct berval *cacert )
{
struct berval *bv = ch_malloc( sizeof(struct berval) + cacert->bv_len );
bv->bv_len = cacert->bv_len;
bv->bv_val = (char *)(bv+1);
AC_MEMCPY( bv->bv_val, cacert->bv_val, bv->bv_len );
return ldap_pvt_thread_pool_submit( &connection_pool, autoca_setca_task, bv );
}
int mdb_tool_entry_open(
BackendDB *be, int mode )
{
/* In Quick mode, commit once per 500 entries */
mdb_writes = 0;
if ( slapMode & SLAP_TOOL_QUICK )
mdb_writes_per_commit = MDB_WRITES_PER_COMMIT;
else
mdb_writes_per_commit = 1;
/* Set up for threaded slapindex */
if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) {
if ( !mdb_tool_info ) {
struct mdb_info *mdb = (struct mdb_info *) be->be_private;
ldap_pvt_thread_mutex_init( &mdb_tool_index_mutex );
ldap_pvt_thread_cond_init( &mdb_tool_index_cond_main );
ldap_pvt_thread_cond_init( &mdb_tool_index_cond_work );
if ( mdb->mi_nattrs ) {
int i;
#if 0 /* threaded indexing has no performance advantage */
mdb_tool_threads = slap_tool_thread_max - 1;
#endif
if ( mdb_tool_threads > 1 ) {
mdb_tool_index_rec = ch_calloc( mdb->mi_nattrs, sizeof( IndexRec ));
mdb_tool_index_tcount = mdb_tool_threads - 1;
for (i=1; i<mdb_tool_threads; i++) {
int *ptr = ch_malloc( sizeof( int ));
*ptr = i;
ldap_pvt_thread_pool_submit( &connection_pool,
mdb_tool_index_task, ptr );
}
mdb_tool_info = mdb;
}
}
}
}
return 0;
}
