/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 2011 The OpenLDAP Foundation.
+ * Copyright 2011-2014 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#include "back-mdb.h"
#include "idl.h"
-static MDB_txn *txn = NULL, *txi = NULL;
+#ifdef MDB_TOOL_IDL_CACHING
+static int mdb_tool_idl_flush( BackendDB *be, MDB_txn *txn );
+
+#define IDBLOCK 1024
+
+typedef struct mdb_tool_idl_cache_entry {
+ struct mdb_tool_idl_cache_entry *next;
+ ID ids[IDBLOCK];
+} mdb_tool_idl_cache_entry;
+
+typedef struct mdb_tool_idl_cache {
+ struct berval kstr;
+ mdb_tool_idl_cache_entry *head, *tail;
+ ID first, last;
+ int count;
+ short offset;
+ short flags;
+} mdb_tool_idl_cache;
+#define WAS_FOUND 0x01
+#define WAS_RANGE 0x02
+
+#define MDB_TOOL_IDL_FLUSH(be, txn) mdb_tool_idl_flush(be, txn)
+#else
+#define MDB_TOOL_IDL_FLUSH(be, txn)
+#endif /* MDB_TOOL_IDL_CACHING */
+
+MDB_txn *mdb_tool_txn = NULL;
+
+static MDB_txn *txi = NULL;
static MDB_cursor *cursor = NULL, *idcursor = NULL;
+static MDB_cursor *mcp = NULL, *mcd = NULL;
static MDB_val key, data;
static ID previd = NOID;
static Filter *tool_filter;
static Entry *tool_next_entry;
-#if 0
static ID mdb_tool_ix_id;
-static Operation *mdb_tool_ix_op;
-static int *mdb_tool_index_threads, mdb_tool_index_tcount;
-static void *mdb_tool_index_rec;
+static BackendDB *mdb_tool_ix_be;
+static MDB_txn *mdb_tool_ix_txn;
+static int mdb_tool_index_tcount, mdb_tool_threads;
+static IndexRec *mdb_tool_index_rec;
+static AttrIxInfo **mdb_tool_axinfo;
static struct mdb_info *mdb_tool_info;
static ldap_pvt_thread_mutex_t mdb_tool_index_mutex;
static ldap_pvt_thread_cond_t mdb_tool_index_cond_main;
static ldap_pvt_thread_cond_t mdb_tool_index_cond_work;
static void * mdb_tool_index_task( void *ctx, void *ptr );
-#endif
static int mdb_writes, mdb_writes_per_commit;
+/* Number of ops per commit in Quick mode.
+ * Batching speeds writes overall, but too large a
+ * batch will fail with MDB_TXN_FULL.
+ */
+#ifndef MDB_WRITES_PER_COMMIT
+#define MDB_WRITES_PER_COMMIT 500
+#endif
+
static int
mdb_tool_entry_get_int( BackendDB *be, ID id, Entry **ep );
int mdb_tool_entry_open(
BackendDB *be, int mode )
{
- /* In Quick mode, commit once per 1000 entries */
+ /* In Quick mode, commit once per 500 entries */
mdb_writes = 0;
if ( slapMode & SLAP_TOOL_QUICK )
- mdb_writes_per_commit = 1000;
+ mdb_writes_per_commit = MDB_WRITES_PER_COMMIT;
else
mdb_writes_per_commit = 1;
-#if 0
+#ifdef MDB_TOOL_IDL_CACHING /* threaded indexing has no performance advantage */
/* 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->bi_nattrs ) {
+ if ( mdb->mi_nattrs ) {
int i;
- mdb_tool_index_threads = ch_malloc( slap_tool_thread_max * sizeof( int ));
- mdb_tool_index_rec = ch_malloc( mdb->bi_nattrs * sizeof( IndexRec ));
- mdb_tool_index_tcount = slap_tool_thread_max - 1;
- for (i=1; i<slap_tool_thread_max; i++) {
- int *ptr = ch_malloc( sizeof( int ));
- *ptr = i;
- ldap_pvt_thread_pool_submit( &connection_pool,
- mdb_tool_index_task, ptr );
+ mdb_tool_threads = slap_tool_thread_max - 1;
+ if ( mdb_tool_threads > 1 ) {
+ mdb_tool_index_rec = ch_calloc( mdb->mi_nattrs, sizeof( IndexRec ));
+ mdb_tool_axinfo = ch_calloc( mdb_tool_threads, sizeof( AttrIxInfo* ) +
+ sizeof( AttrIxInfo ));
+ mdb_tool_axinfo[0] = (AttrIxInfo *)(mdb_tool_axinfo + mdb_tool_threads);
+ for (i=1; i<mdb_tool_threads; i++)
+ mdb_tool_axinfo[i] = mdb_tool_axinfo[i-1]+1;
+ mdb_tool_index_tcount = mdb_tool_threads - 1;
+ mdb_tool_ix_be = be;
+ 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;
}
}
- mdb_tool_info = mdb;
}
}
#endif
int mdb_tool_entry_close(
BackendDB *be )
{
-#if 0
+#ifdef MDB_TOOL_IDL_CACHING
if ( mdb_tool_info ) {
+ int i;
slapd_shutdown = 1;
ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
/* There might still be some threads starting */
- while ( mdb_tool_index_tcount ) {
+ while ( mdb_tool_index_tcount > 0 ) {
ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
&mdb_tool_index_mutex );
}
- mdb_tool_index_tcount = slap_tool_thread_max - 1;
+ mdb_tool_index_tcount = mdb_tool_threads - 1;
ldap_pvt_thread_cond_broadcast( &mdb_tool_index_cond_work );
/* Make sure all threads are stopped */
- while ( mdb_tool_index_tcount ) {
+ while ( mdb_tool_index_tcount > 0 ) {
ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
&mdb_tool_index_mutex );
}
mdb_tool_info = NULL;
slapd_shutdown = 0;
- ch_free( mdb_tool_index_threads );
ch_free( mdb_tool_index_rec );
- mdb_tool_index_tcount = slap_tool_thread_max - 1;
+ mdb_tool_index_tcount = mdb_tool_threads - 1;
+ if (txn)
+ MDB_TOOL_IDL_FLUSH( be, txn );
+ for (i=0; i<mdb_tool_threads; i++) {
+ mdb_tool_idl_cache *ic;
+ mdb_tool_idl_cache_entry *ice;
+ while ((ic = mdb_tool_axinfo[i]->ai_clist)) {
+ mdb_tool_axinfo[i]->ai_clist = ic->head;
+ free(ic);
+ }
+ while ((ice = mdb_tool_axinfo[i]->ai_flist)) {
+ mdb_tool_axinfo[i]->ai_flist = ice->next;
+ free(ice);
+ }
+ }
}
#endif
mdb_cursor_close( cursor );
cursor = NULL;
}
- if( txn ) {
- if ( mdb_txn_commit( txn ))
+ if( mdb_tool_txn ) {
+ int rc;
+ if (( rc = mdb_txn_commit( mdb_tool_txn ))) {
+ Debug( LDAP_DEBUG_ANY,
+ LDAP_XSTRING(mdb_tool_entry_close) ": database %s: "
+ "txn_commit failed: %s (%d)\n",
+ be->be_suffix[0].bv_val, mdb_strerror(rc), rc );
return -1;
- txn = NULL;
+ }
+ mdb_tool_txn = NULL;
}
if( nholes ) {
mdb = (struct mdb_info *) be->be_private;
assert( mdb != NULL );
- if ( !txn ) {
- rc = mdb_txn_begin( mdb->mi_dbenv, NULL, MDB_RDONLY, &txn );
+ if ( !mdb_tool_txn ) {
+ rc = mdb_txn_begin( mdb->mi_dbenv, NULL, MDB_RDONLY, &mdb_tool_txn );
if ( rc )
return NOID;
- rc = mdb_cursor_open( txn, mdb->mi_id2entry, &cursor );
+ rc = mdb_cursor_open( mdb_tool_txn, mdb->mi_id2entry, &cursor );
if ( rc ) {
- mdb_txn_abort( txn );
+ mdb_txn_abort( mdb_tool_txn );
return NOID;
}
}
previd = *(ID *)key.mv_data;
id = previd;
+ if ( !data.mv_size )
+ goto next;
+
if ( tool_filter || tool_base ) {
static Operation op = {0};
static Opheader ohdr = {0};
mdb = (struct mdb_info *) be->be_private;
- if ( !txn ) {
+ if ( !mdb_tool_txn ) {
rc = mdb_txn_begin( mdb->mi_dbenv, NULL, (slapMode & SLAP_TOOL_READONLY) != 0 ?
- MDB_RDONLY : 0, &txn );
+ MDB_RDONLY : 0, &mdb_tool_txn );
if ( rc )
return NOID;
}
op.o_tmpmemctx = NULL;
op.o_tmpmfuncs = &ch_mfuncs;
- rc = mdb_dn2id( &op, txn, dn, &id, NULL, NULL );
+ rc = mdb_dn2id( &op, mdb_tool_txn, NULL, dn, &id, NULL, NULL, NULL );
if ( rc == MDB_NOTFOUND )
return NOID;
goto done;
}
}
+ if ( !data.mv_size ) {
+ rc = LDAP_NO_SUCH_OBJECT;
+ goto done;
+ }
op.o_hdr = &ohdr;
op.o_bd = be;
op.o_tmpmemctx = NULL;
op.o_tmpmfuncs = &ch_mfuncs;
if ( slapMode & SLAP_TOOL_READONLY ) {
- rc = mdb_id2name( &op, txn, &idcursor, id, &dn, &ndn );
+ rc = mdb_id2name( &op, mdb_tool_txn, &idcursor, id, &dn, &ndn );
if ( rc ) {
rc = LDAP_OTHER;
- mdb_entry_return( &op, e );
- e = NULL;
+ if ( e ) {
+ mdb_entry_return( &op, e );
+ e = NULL;
+ }
goto done;
}
if ( tool_base != NULL ) {
ch_free( dn.bv_val );
ch_free( ndn.bv_val );
rc = LDAP_NO_SUCH_OBJECT;
+ goto done;
}
}
}
- rc = mdb_entry_decode( &op, &data, &e );
+ rc = mdb_entry_decode( &op, mdb_tool_txn, &data, &e );
e->e_id = id;
if ( !BER_BVISNULL( &dn )) {
e->e_name = dn;
mdb_tool_entry_get( BackendDB *be, ID id )
{
Entry *e = NULL;
+ int rc;
+ if ( !mdb_tool_txn ) {
+ struct mdb_info *mdb = (struct mdb_info *) be->be_private;
+ rc = mdb_txn_begin( mdb->mi_dbenv, NULL,
+ (slapMode & SLAP_TOOL_READONLY) ? MDB_RDONLY : 0, &mdb_tool_txn );
+ if ( rc )
+ return NULL;
+ }
+ if ( !cursor ) {
+ struct mdb_info *mdb = (struct mdb_info *) be->be_private;
+ rc = mdb_cursor_open( mdb_tool_txn, mdb->mi_id2entry, &cursor );
+ if ( rc ) {
+ mdb_txn_abort( mdb_tool_txn );
+ mdb_tool_txn = NULL;
+ return NULL;
+ }
+ }
(void)mdb_tool_entry_get_int( be, id, &e );
return e;
}
return 0;
}
- rc = mdb_dn2id( op, tid, &ndn, &id, NULL, &nmatched );
+ rc = mdb_dn2id( op, tid, mcp, &ndn, &id, NULL, NULL, &nmatched );
if ( rc == MDB_NOTFOUND ) {
if ( !be_issuffix( op->o_bd, &ndn ) ) {
ID eid = e->e_id;
pid = id;
}
}
- rc = mdb_next_id( op->o_bd, tid, &e->e_id );
+ rc = mdb_next_id( op->o_bd, idcursor, &e->e_id );
if ( rc ) {
snprintf( text->bv_val, text->bv_len,
"next_id failed: %s (%d)",
"=> mdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
return rc;
}
- rc = mdb_dn2id_add( op, tid, pid, e );
+ rc = mdb_dn2id_add( op, mcp, mcd, pid, 1, 1, e );
if ( rc ) {
snprintf( text->bv_val, text->bv_len,
"dn2id_add failed: %s (%d)",
key.mv_data = &e->e_id;
data.mv_size = 0;
data.mv_data = NULL;
- rc = mdb_put( tid, mdb->mi_id2entry, &key, &data, MDB_NOOVERWRITE );
+ rc = mdb_cursor_put( idcursor, &key, &data, MDB_NOOVERWRITE );
if ( rc == MDB_KEYEXIST )
rc = 0;
if ( rc ) {
if ( !mdb->mi_nattrs )
return 0;
-#if 0
- if ( slapMode & SLAP_TOOL_QUICK ) {
+ if ( mdb_tool_threads > 1 ) {
IndexRec *ir;
int i, rc;
Attribute *a;
ir = mdb_tool_index_rec;
- memset(ir, 0, mdb->bi_nattrs * sizeof( IndexRec ));
+ for (i=0; i<mdb->mi_nattrs; i++)
+ ir[i].ir_attrs = NULL;
for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
rc = mdb_index_recset( mdb, a, a->a_desc->ad_type,
if ( rc )
return rc;
}
+ for (i=0; i<mdb->mi_nattrs; i++) {
+ if ( !ir[i].ir_ai )
+ break;
+ rc = mdb_cursor_open( txn, ir[i].ir_ai->ai_dbi,
+ &ir[i].ir_ai->ai_cursor );
+ if ( rc )
+ return rc;
+ }
mdb_tool_ix_id = e->e_id;
- mdb_tool_ix_op = op;
+ mdb_tool_ix_txn = txn;
ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
/* Wait for all threads to be ready */
while ( mdb_tool_index_tcount ) {
ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
&mdb_tool_index_mutex );
}
- for ( i=1; i<slap_tool_thread_max; i++ )
- mdb_tool_index_threads[i] = LDAP_BUSY;
- mdb_tool_index_tcount = slap_tool_thread_max - 1;
+
+ for ( i=1; i<mdb_tool_threads; i++ )
+ mdb_tool_index_rec[i].ir_i = LDAP_BUSY;
+ mdb_tool_index_tcount = mdb_tool_threads - 1;
ldap_pvt_thread_cond_broadcast( &mdb_tool_index_cond_work );
ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
- rc = mdb_index_recrun( op, mdb, ir, e->e_id, 0 );
- if ( rc )
- return rc;
- ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
- for ( i=1; i<slap_tool_thread_max; i++ ) {
- if ( mdb_tool_index_threads[i] == LDAP_BUSY ) {
- ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
- &mdb_tool_index_mutex );
- i--;
- continue;
- }
- if ( mdb_tool_index_threads[i] ) {
- rc = mdb_tool_index_threads[i];
- break;
- }
- }
- ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
- return rc;
+
+ return mdb_index_recrun( op, txn, mdb, ir, e->e_id, 0 );
} else
-#endif
{
return mdb_index_entry_add( op, txn, e );
}
}
+static int
+mdb_tool_index_finish()
+{
+ int i, rc;
+ ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
+ for ( i=1; i<mdb_tool_threads; i++ ) {
+ if ( mdb_tool_index_rec[i].ir_i == LDAP_BUSY ) {
+ ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
+ &mdb_tool_index_mutex );
+ i--;
+ continue;
+ }
+ if ( mdb_tool_index_rec[i].ir_i ) {
+ rc = mdb_tool_index_rec[i].ir_i;
+ break;
+ }
+ }
+ ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
+ return rc;
+}
+
ID mdb_tool_entry_put(
BackendDB *be,
Entry *e,
mdb = (struct mdb_info *) be->be_private;
- if ( !txn ) {
- rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &txn );
- if( rc != 0 ) {
- snprintf( text->bv_val, text->bv_len,
- "txn_begin failed: %s (%d)",
- mdb_strerror(rc), rc );
- Debug( LDAP_DEBUG_ANY,
- "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
- text->bv_val, 0, 0 );
- return NOID;
- }
+ if ( !mdb_tool_txn ) {
+ rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &mdb_tool_txn );
+ if( rc != 0 ) {
+ snprintf( text->bv_val, text->bv_len,
+ "txn_begin failed: %s (%d)",
+ mdb_strerror(rc), rc );
+ Debug( LDAP_DEBUG_ANY,
+ "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
+ text->bv_val, 0, 0 );
+ return NOID;
+ }
+ rc = mdb_cursor_open( mdb_tool_txn, mdb->mi_id2entry, &idcursor );
+ if( rc != 0 ) {
+ snprintf( text->bv_val, text->bv_len,
+ "cursor_open failed: %s (%d)",
+ mdb_strerror(rc), rc );
+ Debug( LDAP_DEBUG_ANY,
+ "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
+ text->bv_val, 0, 0 );
+ return NOID;
+ }
+ if ( !mdb->mi_nextid ) {
+ ID dummy;
+ mdb_next_id( be, idcursor, &dummy );
+ }
+ rc = mdb_cursor_open( mdb_tool_txn, mdb->mi_dn2id, &mcp );
+ if( rc != 0 ) {
+ snprintf( text->bv_val, text->bv_len,
+ "cursor_open failed: %s (%d)",
+ mdb_strerror(rc), rc );
+ Debug( LDAP_DEBUG_ANY,
+ "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
+ text->bv_val, 0, 0 );
+ return NOID;
+ }
+ rc = mdb_cursor_open( mdb_tool_txn, mdb->mi_dn2id, &mcd );
+ if( rc != 0 ) {
+ snprintf( text->bv_val, text->bv_len,
+ "cursor_open failed: %s (%d)",
+ mdb_strerror(rc), rc );
+ Debug( LDAP_DEBUG_ANY,
+ "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
+ text->bv_val, 0, 0 );
+ return NOID;
+ }
}
op.o_hdr = &ohdr;
op.o_tmpmfuncs = &ch_mfuncs;
/* add dn2id indices */
- rc = mdb_tool_next_id( &op, txn, e, text, 0 );
+ rc = mdb_tool_next_id( &op, mdb_tool_txn, e, text, 0 );
if( rc != 0 ) {
goto done;
}
- rc = mdb_tool_index_add( &op, txn, e );
+ if ( mdb_tool_threads > 1 ) {
+ LDAP_SLIST_INSERT_HEAD( &op.o_extra, &mdb_tool_axinfo[0]->ai_oe, oe_next );
+ }
+ rc = mdb_tool_index_add( &op, mdb_tool_txn, e );
if( rc != 0 ) {
snprintf( text->bv_val, text->bv_len,
"index_entry_add failed: err=%d", rc );
/* id2entry index */
- rc = mdb_id2entry_add( &op, txn, e );
+ rc = mdb_id2entry_add( &op, mdb_tool_txn, idcursor, e );
if( rc != 0 ) {
snprintf( text->bv_val, text->bv_len,
"id2entry_add failed: err=%d", rc );
goto done;
}
+ if( mdb->mi_nattrs && mdb_tool_threads > 1 )
+ rc = mdb_tool_index_finish();
+
done:
if( rc == 0 ) {
mdb_writes++;
if ( mdb_writes >= mdb_writes_per_commit ) {
- rc = mdb_txn_commit( txn );
+ unsigned i;
+ MDB_TOOL_IDL_FLUSH( be, mdb_tool_txn );
+ rc = mdb_txn_commit( mdb_tool_txn );
+ for ( i=0; i<mdb->mi_nattrs; i++ )
+ mdb->mi_attrs[i]->ai_cursor = NULL;
mdb_writes = 0;
- txn = NULL;
+ mdb_tool_txn = NULL;
+ idcursor = NULL;
if( rc != 0 ) {
snprintf( text->bv_val, text->bv_len,
"txn_commit failed: %s (%d)",
}
} else {
- mdb_txn_abort( txn );
- txn = NULL;
+ unsigned i;
+ mdb_txn_abort( mdb_tool_txn );
+ mdb_tool_txn = NULL;
+ idcursor = NULL;
+ for ( i=0; i<mdb->mi_nattrs; i++ )
+ mdb->mi_attrs[i]->ai_cursor = NULL;
+ mdb_writes = 0;
snprintf( text->bv_val, text->bv_len,
"txn_aborted! %s (%d)",
rc == LDAP_OTHER ? "Internal error" :
return e->e_id;
}
+static int mdb_dn2id_upgrade( BackendDB *be );
+
int mdb_tool_entry_reindex(
BackendDB *be,
ID id,
assert( tool_base == NULL );
assert( tool_filter == NULL );
+ /* Special: do a dn2id upgrade */
+ if ( adv && adv[0] == slap_schema.si_ad_entryDN ) {
+ /* short-circuit tool_entry_next() */
+ mdb_cursor_get( cursor, &key, &data, MDB_LAST );
+ return mdb_dn2id_upgrade( be );
+ }
+
/* No indexes configured, nothing to do. Could return an
* error here to shortcut things.
*/
mi->mi_nattrs = i;
}
- if ( slapMode & SLAP_TRUNCATE_MODE ) {
- int i;
- for ( i=0; i < mi->mi_nattrs; i++ ) {
- rc = mdb_drop( txn, mi->mi_attrs[i]->ai_dbi, 0 );
- if ( rc ) {
- Debug( LDAP_DEBUG_ANY,
- LDAP_XSTRING(mdb_tool_entry_reindex)
- ": (Truncate) mdb_drop(%s) failed: %s (%d)\n",
- mi->mi_attrs[i]->ai_desc->ad_type->sat_cname.bv_val,
- mdb_strerror(rc), rc );
- return -1;
- }
- }
- slapMode ^= SLAP_TRUNCATE_MODE;
- }
-
e = mdb_tool_entry_get( be, id );
if( e == NULL ) {
}
}
+ if ( slapMode & SLAP_TRUNCATE_MODE ) {
+ int i;
+ for ( i=0; i < mi->mi_nattrs; i++ ) {
+ rc = mdb_drop( txi, mi->mi_attrs[i]->ai_dbi, 0 );
+ if ( rc ) {
+ Debug( LDAP_DEBUG_ANY,
+ LDAP_XSTRING(mdb_tool_entry_reindex)
+ ": (Truncate) mdb_drop(%s) failed: %s (%d)\n",
+ mi->mi_attrs[i]->ai_desc->ad_type->sat_cname.bv_val,
+ mdb_strerror(rc), rc );
+ return -1;
+ }
+ }
+ slapMode ^= SLAP_TRUNCATE_MODE;
+ }
+
/*
* just (re)add them for now
- * assume that some other routine (not yet implemented)
- * will zap index databases
- *
+ * Use truncate mode to empty/reset index databases
*/
Debug( LDAP_DEBUG_TRACE,
- "=> " LDAP_XSTRING(mdb_tool_entry_reindex) "( %ld, \"%s\" )\n",
- (long) id, e->e_dn, 0 );
+ "=> " LDAP_XSTRING(mdb_tool_entry_reindex) "( %ld )\n",
+ (long) id, 0, 0 );
op.o_hdr = &ohdr;
op.o_bd = be;
if( rc == 0 ) {
mdb_writes++;
if ( mdb_writes >= mdb_writes_per_commit ) {
+ MDB_val key;
+ unsigned i;
+ MDB_TOOL_IDL_FLUSH( be, txi );
rc = mdb_txn_commit( txi );
+ mdb_writes = 0;
+ for ( i=0; i<mi->mi_nattrs; i++ )
+ mi->mi_attrs[i]->ai_cursor = NULL;
if( rc != 0 ) {
Debug( LDAP_DEBUG_ANY,
"=> " LDAP_XSTRING(mdb_tool_entry_reindex)
mdb_strerror(rc), rc, 0 );
e->e_id = NOID;
}
+ mdb_cursor_close( cursor );
txi = NULL;
+ /* Must close the read txn to allow old pages to be reclaimed. */
+ mdb_txn_abort( mdb_tool_txn );
+ /* and then reopen it so that tool_entry_next still works. */
+ mdb_txn_begin( mi->mi_dbenv, NULL, MDB_RDONLY, &mdb_tool_txn );
+ mdb_cursor_open( mdb_tool_txn, mi->mi_id2entry, &cursor );
+ key.mv_data = &id;
+ key.mv_size = sizeof(ID);
+ mdb_cursor_get( cursor, &key, NULL, MDB_SET );
}
} else {
+ unsigned i;
+ mdb_writes = 0;
+ mdb_cursor_close( cursor );
+ cursor = NULL;
mdb_txn_abort( txi );
+ for ( i=0; i<mi->mi_nattrs; i++ )
+ mi->mi_attrs[i]->ai_cursor = NULL;
Debug( LDAP_DEBUG_ANY,
"=> " LDAP_XSTRING(mdb_tool_entry_reindex)
": txn_aborted! err=%d\n",
{
int rc;
struct mdb_info *mdb;
- MDB_txn *tid;
Operation op = {0};
Opheader ohdr = {0};
mdb_cursor_close( cursor );
cursor = NULL;
}
- rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &tid );
- if( rc != 0 ) {
- snprintf( text->bv_val, text->bv_len,
- "txn_begin failed: %s (%d)",
- mdb_strerror(rc), rc );
- Debug( LDAP_DEBUG_ANY,
- "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": %s\n",
- text->bv_val, 0, 0 );
- return NOID;
+ if ( !mdb_tool_txn ) {
+ rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &mdb_tool_txn );
+ if( rc != 0 ) {
+ snprintf( text->bv_val, text->bv_len,
+ "txn_begin failed: %s (%d)",
+ mdb_strerror(rc), rc );
+ Debug( LDAP_DEBUG_ANY,
+ "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": %s\n",
+ text->bv_val, 0, 0 );
+ return NOID;
+ }
}
op.o_hdr = &ohdr;
op.o_tmpmfuncs = &ch_mfuncs;
/* id2entry index */
- rc = mdb_id2entry_update( &op, tid, e );
+ rc = mdb_id2entry_update( &op, mdb_tool_txn, NULL, e );
if( rc != 0 ) {
snprintf( text->bv_val, text->bv_len,
"id2entry_update failed: err=%d", rc );
done:
if( rc == 0 ) {
- rc = mdb_txn_commit( tid );
+ rc = mdb_txn_commit( mdb_tool_txn );
if( rc != 0 ) {
snprintf( text->bv_val, text->bv_len,
"txn_commit failed: %s (%d)",
}
} else {
- mdb_txn_abort( tid );
+ mdb_txn_abort( mdb_tool_txn );
snprintf( text->bv_val, text->bv_len,
"txn_aborted! %s (%d)",
mdb_strerror(rc), rc );
text->bv_val, 0, 0 );
e->e_id = NOID;
}
+ mdb_tool_txn = NULL;
+ idcursor = NULL;
return e->e_id;
}
-#if 0
static void *
mdb_tool_index_task( void *ctx, void *ptr )
{
int base = *(int *)ptr;
+ Operation op = {0};
+ Opheader ohdr = {0};
+ AttrIxInfo ai = {0}, *aio;
free( ptr );
+ op.o_hdr = &ohdr;
+ op.o_bd = mdb_tool_ix_be;
+ op.o_tmpmemctx = NULL;
+ op.o_tmpmfuncs = &ch_mfuncs;
+ aio = mdb_tool_axinfo[base];
+ mdb_tool_axinfo[base] = &ai;
+ LDAP_SLIST_INSERT_HEAD( &op.o_extra, &ai.ai_oe, oe_next );
while ( 1 ) {
ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
mdb_tool_index_tcount--;
mdb_tool_index_tcount--;
if ( !mdb_tool_index_tcount )
ldap_pvt_thread_cond_signal( &mdb_tool_index_cond_main );
+ *aio = ai;
+ mdb_tool_axinfo[base] = aio;
ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
break;
}
ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
-
- mdb_tool_index_threads[base] = mdb_index_recrun( mdb_tool_ix_op,
+ mdb_tool_index_rec[base].ir_i = mdb_index_recrun( &op,
+ mdb_tool_ix_txn,
mdb_tool_info, mdb_tool_index_rec, mdb_tool_ix_id, base );
}
return NULL;
}
+
+#ifdef MDB_TOOL_IDL_CACHING
+static int
+mdb_tool_idl_cmp( const void *v1, const void *v2 )
+{
+ const mdb_tool_idl_cache *c1 = v1, *c2 = v2;
+ int rc;
+
+ if (( rc = c1->kstr.bv_len - c2->kstr.bv_len )) return rc;
+ return memcmp( c1->kstr.bv_val, c2->kstr.bv_val, c1->kstr.bv_len );
+}
+
+static int
+mdb_tool_idl_flush_one( MDB_cursor *mc, AttrIxInfo *ai, mdb_tool_idl_cache *ic )
+{
+ mdb_tool_idl_cache_entry *ice;
+ MDB_val key, data[2];
+ int i, rc;
+ ID id, nid;
+
+ /* Freshly allocated, ignore it */
+ if ( !ic->head && ic->count <= MDB_IDL_DB_SIZE ) {
+ return 0;
+ }
+
+ key.mv_data = ic->kstr.bv_val;
+ key.mv_size = ic->kstr.bv_len;
+
+ if ( ic->count > MDB_IDL_DB_SIZE ) {
+ while ( ic->flags & WAS_FOUND ) {
+ rc = mdb_cursor_get( mc, &key, data, MDB_SET );
+ if ( rc ) {
+ /* FIXME: find out why this happens */
+ ic->flags = 0;
+ break;
+ }
+ if ( ic->flags & WAS_RANGE ) {
+ /* Skip lo */
+ rc = mdb_cursor_get( mc, &key, data, MDB_NEXT_DUP );
+
+ /* Get hi */
+ rc = mdb_cursor_get( mc, &key, data, MDB_NEXT_DUP );
+
+ /* Store range hi */
+ data[0].mv_data = &ic->last;
+ rc = mdb_cursor_put( mc, &key, data, MDB_CURRENT );
+ } else {
+ /* Delete old data, replace with range */
+ ic->first = *(ID *)data[0].mv_data;
+ mdb_cursor_del( mc, MDB_NODUPDATA );
+ }
+ break;
+ }
+ if ( !(ic->flags & WAS_RANGE)) {
+ /* range, didn't exist before */
+ nid = 0;
+ data[0].mv_size = sizeof(ID);
+ data[0].mv_data = &nid;
+ rc = mdb_cursor_put( mc, &key, data, 0 );
+ if ( rc == 0 ) {
+ data[0].mv_data = &ic->first;
+ rc = mdb_cursor_put( mc, &key, data, 0 );
+ if ( rc == 0 ) {
+ data[0].mv_data = &ic->last;
+ rc = mdb_cursor_put( mc, &key, data, 0 );
+ }
+ }
+ if ( rc ) {
+ rc = -1;
+ }
+ }
+ } else {
+ /* Normal write */
+ int n;
+
+ data[0].mv_size = sizeof(ID);
+ rc = 0;
+ for ( ice = ic->head, n=0; ice; ice = ice->next, n++ ) {
+ int end;
+ if ( ice->next ) {
+ end = IDBLOCK;
+ } else {
+ end = (ic->count-ic->offset) & (IDBLOCK-1);
+ if ( !end )
+ end = IDBLOCK;
+ }
+ data[1].mv_size = end;
+ data[0].mv_data = ice->ids;
+ rc = mdb_cursor_put( mc, &key, data, MDB_APPENDDUP|MDB_MULTIPLE );
+ if ( rc ) {
+ rc = -1;
+ break;
+ }
+ }
+ if ( ic->head ) {
+ ic->tail->next = ai->ai_flist;
+ ai->ai_flist = ic->head;
+ }
+ }
+ ic->head = ai->ai_clist;
+ ai->ai_clist = ic;
+ return rc;
+}
+
+static int
+mdb_tool_idl_flush_db( MDB_txn *txn, AttrInfo *ai, AttrIxInfo *ax )
+{
+ MDB_cursor *mc;
+ Avlnode *root;
+ int rc;
+
+ mdb_cursor_open( txn, ai->ai_dbi, &mc );
+ root = tavl_end( ai->ai_root, TAVL_DIR_LEFT );
+ do {
+ rc = mdb_tool_idl_flush_one( mc, ax, root->avl_data );
+ if ( rc != -1 )
+ rc = 0;
+ } while ((root = tavl_next(root, TAVL_DIR_RIGHT)));
+ mdb_cursor_close( mc );
+
+ return rc;
+}
+
+static int
+mdb_tool_idl_flush( BackendDB *be, MDB_txn *txn )
+{
+ struct mdb_info *mdb = (struct mdb_info *) be->be_private;
+ int rc = 0;
+ unsigned int i, dbi;
+
+ for ( i=0; i < mdb->mi_nattrs; i++ ) {
+ if ( !mdb->mi_attrs[i]->ai_root ) continue;
+ rc = mdb_tool_idl_flush_db( txn, mdb->mi_attrs[i], mdb_tool_axinfo[i % mdb_tool_threads] );
+ tavl_free(mdb->mi_attrs[i]->ai_root, NULL);
+ mdb->mi_attrs[i]->ai_root = NULL;
+ if ( rc )
+ break;
+ }
+ return rc;
+}
+
+int mdb_tool_idl_add(
+ BackendDB *be,
+ MDB_cursor *mc,
+ struct berval *keys,
+ ID id )
+{
+ MDB_dbi dbi;
+ mdb_tool_idl_cache *ic, itmp;
+ mdb_tool_idl_cache_entry *ice;
+ int i, rc, lcount;
+ AttrIxInfo *ax = (AttrIxInfo *)mc;
+ AttrInfo *ai = (AttrInfo *)ax->ai_ai;
+ mc = ai->ai_cursor;
+
+ dbi = ai->ai_dbi;
+ for (i=0; keys[i].bv_val; i++) {
+ itmp.kstr = keys[i];
+ ic = tavl_find( (Avlnode *)ai->ai_root, &itmp, mdb_tool_idl_cmp );
+
+ /* No entry yet, create one */
+ if ( !ic ) {
+ MDB_val key, data;
+ ID nid;
+ int rc;
+
+ if ( ax->ai_clist ) {
+ ic = ax->ai_clist;
+ ax->ai_clist = ic->head;
+ } else {
+ ic = ch_malloc( sizeof( mdb_tool_idl_cache ) + itmp.kstr.bv_len + 4 );
+ }
+ ic->kstr.bv_len = itmp.kstr.bv_len;
+ ic->kstr.bv_val = (char *)(ic+1);
+ memcpy( ic->kstr.bv_val, itmp.kstr.bv_val, ic->kstr.bv_len );
+ ic->head = ic->tail = NULL;
+ ic->last = 0;
+ ic->count = 0;
+ ic->offset = 0;
+ ic->flags = 0;
+ tavl_insert( (Avlnode **)&ai->ai_root, ic, mdb_tool_idl_cmp,
+ avl_dup_error );
+
+ /* load existing key count here */
+ key.mv_size = keys[i].bv_len;
+ key.mv_data = keys[i].bv_val;
+ rc = mdb_cursor_get( mc, &key, &data, MDB_SET );
+ if ( rc == 0 ) {
+ ic->flags |= WAS_FOUND;
+ nid = *(ID *)data.mv_data;
+ if ( nid == 0 ) {
+ ic->count = MDB_IDL_DB_SIZE+1;
+ ic->flags |= WAS_RANGE;
+ } else {
+ size_t count;
+
+ mdb_cursor_count( mc, &count );
+ ic->count = count;
+ ic->first = nid;
+ ic->offset = count & (IDBLOCK-1);
+ }
+ }
+ }
+ /* are we a range already? */
+ if ( ic->count > MDB_IDL_DB_SIZE ) {
+ ic->last = id;
+ continue;
+ /* Are we at the limit, and converting to a range? */
+ } else if ( ic->count == MDB_IDL_DB_SIZE ) {
+ if ( ic->head ) {
+ ic->tail->next = ax->ai_flist;
+ ax->ai_flist = ic->head;
+ }
+ ic->head = ic->tail = NULL;
+ ic->last = id;
+ ic->count++;
+ continue;
+ }
+ /* No free block, create that too */
+ lcount = (ic->count-ic->offset) & (IDBLOCK-1);
+ if ( !ic->tail || lcount == 0) {
+ if ( ax->ai_flist ) {
+ ice = ax->ai_flist;
+ ax->ai_flist = ice->next;
+ } else {
+ ice = ch_malloc( sizeof( mdb_tool_idl_cache_entry ));
+ }
+ ice->next = NULL;
+ if ( !ic->head ) {
+ ic->head = ice;
+ } else {
+ ic->tail->next = ice;
+ }
+ ic->tail = ice;
+ if ( lcount )
+ ice->ids[lcount-1] = 0;
+ if ( !ic->count )
+ ic->first = id;
+ }
+ ice = ic->tail;
+ if (!lcount || ice->ids[lcount-1] != id) {
+ ice->ids[lcount] = id;
+ ic->count++;
+ }
+ }
+
+ return 0;
+}
+#endif /* MDB_TOOL_IDL_CACHING */
+
+/* Upgrade from pre 2.4.34 dn2id format */
+
+#include <ac/unistd.h>
+#include <lutil_meter.h>
+
+#define STACKSIZ 2048
+
+typedef struct rec {
+ ID id;
+ size_t len;
+ char rdn[512];
+} rec;
+
+static int
+mdb_dn2id_upgrade( BackendDB *be ) {
+ struct mdb_info *mi = (struct mdb_info *) be->be_private;
+ MDB_txn *mt;
+ MDB_cursor *mc = NULL;
+ MDB_val key, data;
+ char *ptr;
+ int rc, writes=0, depth=0;
+ int enable_meter = 0;
+ ID id = 0, *num, count = 0;
+ rec *stack;
+ lutil_meter_t meter;
+
+ if (!(mi->mi_flags & MDB_NEED_UPGRADE)) {
+ Debug( LDAP_DEBUG_ANY, "database %s: No upgrade needed.\n",
+ be->be_suffix[0].bv_val, 0, 0 );
+ return 0;
+ }
+
+ {
+ MDB_stat st;
+
+ mdb_stat(mdb_cursor_txn(cursor), mi->mi_dbis[MDB_ID2ENTRY], &st);
+ if (!st.ms_entries) {
+ /* Empty DB, nothing to upgrade? */
+ return 0;
+ }
+ if (isatty(2))
+ enable_meter = !lutil_meter_open(&meter,
+ &lutil_meter_text_display,
+ &lutil_meter_linear_estimator,
+ st.ms_entries);
+ }
+
+ num = ch_malloc(STACKSIZ * (sizeof(ID) + sizeof(rec)));
+ stack = (rec *)(num + STACKSIZ);
+
+ rc = mdb_txn_begin(mi->mi_dbenv, NULL, 0, &mt);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_txn_begin failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ rc = mdb_cursor_open(mt, mi->mi_dbis[MDB_DN2ID], &mc);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_open failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+
+ key.mv_size = sizeof(ID);
+ /* post-order depth-first update */
+ for(;;) {
+ size_t dkids;
+ unsigned char *ptr;
+
+ /* visit */
+ key.mv_data = &id;
+ stack[depth].id = id;
+ rc = mdb_cursor_get(mc, &key, &data, MDB_SET);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_get failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ num[depth] = 1;
+
+ rc = mdb_cursor_count(mc, &dkids);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_count failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ if (dkids > 1) {
+ rc = mdb_cursor_get(mc, &key, &data, MDB_NEXT_DUP);
+down:
+ ptr = (unsigned char *)data.mv_data + data.mv_size - sizeof(ID);
+ memcpy(&id, ptr, sizeof(ID));
+ depth++;
+ memcpy(stack[depth].rdn, data.mv_data, data.mv_size);
+ stack[depth].len = data.mv_size;
+ continue;
+ }
+
+
+ /* pop: write updated count, advance to next node */
+pop:
+ /* update superior counts */
+ if (depth)
+ num[depth-1] += num[depth];
+
+ key.mv_data = &id;
+ id = stack[depth-1].id;
+ data.mv_data = stack[depth].rdn;
+ data.mv_size = stack[depth].len;
+ rc = mdb_cursor_get(mc, &key, &data, MDB_GET_BOTH);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_get(BOTH) failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ data.mv_data = stack[depth].rdn;
+ ptr = (unsigned char *)data.mv_data + data.mv_size;
+ memcpy(ptr, &num[depth], sizeof(ID));
+ data.mv_size += sizeof(ID);
+ rc = mdb_cursor_del(mc, 0);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_del failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ rc = mdb_cursor_put(mc, &key, &data, 0);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_put failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ count++;
+#if 1
+ if (enable_meter)
+ lutil_meter_update(&meter, count, 0);
+#else
+ {
+ int len;
+ ptr = data.mv_data;
+ len = (ptr[0] & 0x7f) << 8 | ptr[1];
+ printf("ID: %zu, %zu, %.*s\n", stack[depth].id, num[depth], len, ptr+2);
+ }
#endif
+ writes++;
+ if (writes == 1000) {
+ mdb_cursor_close(mc);
+ rc = mdb_txn_commit(mt);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_txn_commit failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ rc = mdb_txn_begin(mi->mi_dbenv, NULL, 0, &mt);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_txn_begin(2) failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ rc = mdb_cursor_open(mt, mi->mi_dbis[MDB_DN2ID], &mc);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_open(2) failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ rc = mdb_cursor_get(mc, &key, &data, MDB_GET_BOTH);
+ if (rc) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_cursor_get(2) failed, %s (%d)\n",
+ mdb_strerror(rc), rc, 0 );
+ goto leave;
+ }
+ writes = 0;
+ }
+ depth--;
+
+ rc = mdb_cursor_get(mc, &key, &data, MDB_NEXT_DUP);
+ if (rc == 0)
+ goto down;
+ rc = 0;
+ if (depth)
+ goto pop;
+ else
+ break;
+ }
+leave:
+ mdb_cursor_close(mc);
+ if (mt) {
+ int r2;
+ r2 = mdb_txn_commit(mt);
+ if (r2) {
+ Debug(LDAP_DEBUG_ANY, "mdb_dn2id_upgrade: mdb_txn_commit(2) failed, %s (%d)\n",
+ mdb_strerror(r2), r2, 0 );
+ if (!rc)
+ rc = r2;
+ }
+ }
+ ch_free(num);
+ if (enable_meter) {
+ lutil_meter_update(&meter, count, 1);
+ lutil_meter_close(&meter);
+ }
+ return rc;
+}
projects / openldap / blobdiff