git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/tools.c

   1 /* tools.c - tools for slap tools */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2000-2015 The OpenLDAP Foundation.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted only as authorized by the OpenLDAP
  10  * Public License.
  11  *
  12  * A copy of this license is available in the file LICENSE in the
  13  * top-level directory of the distribution or, alternatively, at
  14  * <http://www.OpenLDAP.org/license.html>.
  15  */
  16
  17 #include "portable.h"
  18
  19 #include <stdio.h>
  20 #include <ac/string.h>
  21 #include <ac/errno.h>
  22
  23 #define AVL_INTERNAL
  24 #include "back-bdb.h"
  25 #include "idl.h"
  26
  27 static DBC *cursor = NULL;
  28 static DBT key, data;
  29 static EntryHeader eh;
  30 static ID nid, previd = NOID;
  31 static char ehbuf[16];
  32
  33 typedef struct dn_id {
  34         ID id;
  35         struct berval dn;
  36 } dn_id;
  37
  38 #define HOLE_SIZE       4096
  39 static dn_id hbuf[HOLE_SIZE], *holes = hbuf;
  40 static unsigned nhmax = HOLE_SIZE;
  41 static unsigned nholes;
  42
  43 static int index_nattrs;
  44
  45 static struct berval    *tool_base;
  46 static int              tool_scope;
  47 static Filter           *tool_filter;
  48 static Entry            *tool_next_entry;
  49
  50 #ifdef BDB_TOOL_IDL_CACHING
  51 #define bdb_tool_idl_cmp                BDB_SYMBOL(tool_idl_cmp)
  52 #define bdb_tool_idl_flush_one          BDB_SYMBOL(tool_idl_flush_one)
  53 #define bdb_tool_idl_flush              BDB_SYMBOL(tool_idl_flush)
  54
  55 static int bdb_tool_idl_flush( BackendDB *be );
  56
  57 #define IDBLOCK 1024
  58
  59 typedef struct bdb_tool_idl_cache_entry {
  60         struct bdb_tool_idl_cache_entry *next;
  61         ID ids[IDBLOCK];
  62 } bdb_tool_idl_cache_entry;
  63
  64 typedef struct bdb_tool_idl_cache {
  65         struct berval kstr;
  66         bdb_tool_idl_cache_entry *head, *tail;
  67         ID first, last;
  68         int count;
  69 } bdb_tool_idl_cache;
  70
  71 static bdb_tool_idl_cache_entry *bdb_tool_idl_free_list;
  72 #endif  /* BDB_TOOL_IDL_CACHING */
  73
  74 static ID bdb_tool_ix_id;
  75 static Operation *bdb_tool_ix_op;
  76 static int *bdb_tool_index_threads, bdb_tool_index_tcount;
  77 static void *bdb_tool_index_rec;
  78 static struct bdb_info *bdb_tool_info;
  79 static ldap_pvt_thread_mutex_t bdb_tool_index_mutex;
  80 static ldap_pvt_thread_cond_t bdb_tool_index_cond_main;
  81 static ldap_pvt_thread_cond_t bdb_tool_index_cond_work;
  82
  83 #if DB_VERSION_FULL >= 0x04060000
  84 #define USE_TRICKLE     1
  85 #else
  86 /* Seems to slow things down too much in BDB 4.5 */
  87 #undef USE_TRICKLE
  88 #endif
  89
  90 #ifdef USE_TRICKLE
  91 static ldap_pvt_thread_mutex_t bdb_tool_trickle_mutex;
  92 static ldap_pvt_thread_cond_t bdb_tool_trickle_cond;
  93 static ldap_pvt_thread_cond_t bdb_tool_trickle_cond_end;
  94
  95 static void * bdb_tool_trickle_task( void *ctx, void *ptr );
  96 static int bdb_tool_trickle_active;
  97 #endif
  98
  99 static void * bdb_tool_index_task( void *ctx, void *ptr );
 100
 101 static int
 102 bdb_tool_entry_get_int( BackendDB *be, ID id, Entry **ep );
 103
 104 static int bdb_tool_threads;
 105
 106 int bdb_tool_entry_open(
 107         BackendDB *be, int mode )
 108 {
 109         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
 110
 111         /* initialize key and data thangs */
 112         DBTzero( &key );
 113         DBTzero( &data );
 114         key.flags = DB_DBT_USERMEM;
 115         key.data = &nid;
 116         key.size = key.ulen = sizeof( nid );
 117         data.flags = DB_DBT_USERMEM;
 118
 119         if (cursor == NULL) {
 120                 int rc = bdb->bi_id2entry->bdi_db->cursor(
 121                         bdb->bi_id2entry->bdi_db, bdb->bi_cache.c_txn, &cursor,
 122                         bdb->bi_db_opflags );
 123                 if( rc != 0 ) {
 124                         return -1;
 125                 }
 126         }
 127
 128         /* Set up for threaded slapindex */
 129         if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) {
 130                 if ( !bdb_tool_info ) {
 131 #ifdef USE_TRICKLE
 132                         ldap_pvt_thread_mutex_init( &bdb_tool_trickle_mutex );
 133                         ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond );
 134                         ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond_end );
 135                         ldap_pvt_thread_pool_submit( &connection_pool, bdb_tool_trickle_task, bdb->bi_dbenv );
 136 #endif
 137
 138                         ldap_pvt_thread_mutex_init( &bdb_tool_index_mutex );
 139                         ldap_pvt_thread_cond_init( &bdb_tool_index_cond_main );
 140                         ldap_pvt_thread_cond_init( &bdb_tool_index_cond_work );
 141                         if ( bdb->bi_nattrs ) {
 142                                 int i;
 143                                 bdb_tool_threads = slap_tool_thread_max - 1;
 144                                 if ( bdb_tool_threads > 1 ) {
 145                                         bdb_tool_index_threads = ch_malloc( bdb_tool_threads * sizeof( int ));
 146                                         bdb_tool_index_rec = ch_malloc( bdb->bi_nattrs * sizeof( IndexRec ));
 147                                         bdb_tool_index_tcount = bdb_tool_threads - 1;
 148                                         for (i=1; i<bdb_tool_threads; i++) {
 149                                                 int *ptr = ch_malloc( sizeof( int ));
 150                                                 *ptr = i;
 151                                                 ldap_pvt_thread_pool_submit( &connection_pool,
 152                                                         bdb_tool_index_task, ptr );
 153                                         }
 154                                 }
 155                         }
 156                         bdb_tool_info = bdb;
 157                 }
 158         }
 159
 160         return 0;
 161 }
 162
 163 int bdb_tool_entry_close(
 164         BackendDB *be )
 165 {
 166         if ( bdb_tool_info ) {
 167                 slapd_shutdown = 1;
 168 #ifdef USE_TRICKLE
 169                 ldap_pvt_thread_mutex_lock( &bdb_tool_trickle_mutex );
 170
 171                 /* trickle thread may not have started yet */
 172                 while ( !bdb_tool_trickle_active )
 173                         ldap_pvt_thread_cond_wait( &bdb_tool_trickle_cond_end,
 174                                         &bdb_tool_trickle_mutex );
 175
 176                 ldap_pvt_thread_cond_signal( &bdb_tool_trickle_cond );
 177                 while ( bdb_tool_trickle_active )
 178                         ldap_pvt_thread_cond_wait( &bdb_tool_trickle_cond_end,
 179                                         &bdb_tool_trickle_mutex );
 180                 ldap_pvt_thread_mutex_unlock( &bdb_tool_trickle_mutex );
 181 #endif
 182                 if ( bdb_tool_threads > 1 ) {
 183                         ldap_pvt_thread_mutex_lock( &bdb_tool_index_mutex );
 184
 185                         /* There might still be some threads starting */
 186                         while ( bdb_tool_index_tcount > 0 ) {
 187                                 ldap_pvt_thread_cond_wait( &bdb_tool_index_cond_main,
 188                                                 &bdb_tool_index_mutex );
 189                         }
 190
 191                         bdb_tool_index_tcount = bdb_tool_threads - 1;
 192                         ldap_pvt_thread_cond_broadcast( &bdb_tool_index_cond_work );
 193
 194                         /* Make sure all threads are stopped */
 195                         while ( bdb_tool_index_tcount > 0 ) {
 196                                 ldap_pvt_thread_cond_wait( &bdb_tool_index_cond_main,
 197                                         &bdb_tool_index_mutex );
 198                         }
 199                         ldap_pvt_thread_mutex_unlock( &bdb_tool_index_mutex );
 200
 201                         ch_free( bdb_tool_index_threads );
 202                         ch_free( bdb_tool_index_rec );
 203                         bdb_tool_index_tcount = bdb_tool_threads - 1;
 204                 }
 205                 bdb_tool_info = NULL;
 206                 slapd_shutdown = 0;
 207         }
 208
 209         if( eh.bv.bv_val ) {
 210                 ch_free( eh.bv.bv_val );
 211                 eh.bv.bv_val = NULL;
 212         }
 213
 214         if( cursor ) {
 215                 cursor->c_close( cursor );
 216                 cursor = NULL;
 217         }
 218
 219 #ifdef BDB_TOOL_IDL_CACHING
 220         bdb_tool_idl_flush( be );
 221 #endif
 222
 223         if( nholes ) {
 224                 unsigned i;
 225                 fprintf( stderr, "Error, entries missing!\n");
 226                 for (i=0; i<nholes; i++) {
 227                         fprintf(stderr, "  entry %ld: %s\n",
 228                                 holes[i].id, holes[i].dn.bv_val);
 229                 }
 230                 return -1;
 231         }
 232
 233         return 0;
 234 }
 235
 236 ID
 237 bdb_tool_entry_first_x(
 238         BackendDB *be,
 239         struct berval *base,
 240         int scope,
 241         Filter *f )
 242 {
 243         tool_base = base;
 244         tool_scope = scope;
 245         tool_filter = f;
 246
 247         return bdb_tool_entry_next( be );
 248 }
 249
 250 ID bdb_tool_entry_next(
 251         BackendDB *be )
 252 {
 253         int rc;
 254         ID id;
 255         struct bdb_info *bdb;
 256
 257         assert( be != NULL );
 258         assert( slapMode & SLAP_TOOL_MODE );
 259
 260         bdb = (struct bdb_info *) be->be_private;
 261         assert( bdb != NULL );
 262
 263 next:;
 264         /* Get the header */
 265         data.ulen = data.dlen = sizeof( ehbuf );
 266         data.data = ehbuf;
 267         data.flags |= DB_DBT_PARTIAL;
 268         rc = cursor->c_get( cursor, &key, &data, DB_NEXT );
 269
 270         if( rc ) {
 271                 /* If we're doing linear indexing and there are more attrs to
 272                  * index, and we're at the end of the database, start over.
 273                  */
 274                 if ( index_nattrs && rc == DB_NOTFOUND ) {
 275                         /* optional - do a checkpoint here? */
 276                         bdb_attr_info_free( bdb->bi_attrs[0] );
 277                         bdb->bi_attrs[0] = bdb->bi_attrs[index_nattrs];
 278                         index_nattrs--;
 279                         rc = cursor->c_get( cursor, &key, &data, DB_FIRST );
 280                         if ( rc ) {
 281                                 return NOID;
 282                         }
 283                 } else {
 284                         return NOID;
 285                 }
 286         }
 287
 288         BDB_DISK2ID( key.data, &id );
 289         previd = id;
 290
 291         if ( tool_filter || tool_base ) {
 292                 static Operation op = {0};
 293                 static Opheader ohdr = {0};
 294
 295                 op.o_hdr = &ohdr;
 296                 op.o_bd = be;
 297                 op.o_tmpmemctx = NULL;
 298                 op.o_tmpmfuncs = &ch_mfuncs;
 299
 300                 if ( tool_next_entry ) {
 301                         bdb_entry_release( &op, tool_next_entry, 0 );
 302                         tool_next_entry = NULL;
 303                 }
 304
 305                 rc = bdb_tool_entry_get_int( be, id, &tool_next_entry );
 306                 if ( rc == LDAP_NO_SUCH_OBJECT ) {
 307                         goto next;
 308                 }
 309
 310                 assert( tool_next_entry != NULL );
 311
 312 #ifdef BDB_HIER
 313                 /* TODO: needed until BDB_HIER is handled accordingly
 314                  * in bdb_tool_entry_get_int() */
 315                 if ( tool_base && !dnIsSuffixScope( &tool_next_entry->e_nname, tool_base, tool_scope ) )
 316                 {
 317                         bdb_entry_release( &op, tool_next_entry, 0 );
 318                         tool_next_entry = NULL;
 319                         goto next;
 320                 }
 321 #endif
 322
 323                 if ( tool_filter && test_filter( NULL, tool_next_entry, tool_filter ) != LDAP_COMPARE_TRUE )
 324                 {
 325                         bdb_entry_release( &op, tool_next_entry, 0 );
 326                         tool_next_entry = NULL;
 327                         goto next;
 328                 }
 329         }
 330
 331         return id;
 332 }
 333
 334 ID bdb_tool_dn2id_get(
 335         Backend *be,
 336         struct berval *dn
 337 )
 338 {
 339         Operation op = {0};
 340         Opheader ohdr = {0};
 341         EntryInfo *ei = NULL;
 342         int rc;
 343
 344         if ( BER_BVISEMPTY(dn) )
 345                 return 0;
 346
 347         op.o_hdr = &ohdr;
 348         op.o_bd = be;
 349         op.o_tmpmemctx = NULL;
 350         op.o_tmpmfuncs = &ch_mfuncs;
 351
 352         rc = bdb_cache_find_ndn( &op, 0, dn, &ei );
 353         if ( ei ) bdb_cache_entryinfo_unlock( ei );
 354         if ( rc == DB_NOTFOUND )
 355                 return NOID;
 356
 357         return ei->bei_id;
 358 }
 359
 360 static int
 361 bdb_tool_entry_get_int( BackendDB *be, ID id, Entry **ep )
 362 {
 363         Entry *e = NULL;
 364         char *dptr;
 365         int rc, eoff;
 366
 367         assert( be != NULL );
 368         assert( slapMode & SLAP_TOOL_MODE );
 369
 370         if ( ( tool_filter || tool_base ) && id == previd && tool_next_entry != NULL ) {
 371                 *ep = tool_next_entry;
 372                 tool_next_entry = NULL;
 373                 return LDAP_SUCCESS;
 374         }
 375
 376         if ( id != previd ) {
 377                 data.ulen = data.dlen = sizeof( ehbuf );
 378                 data.data = ehbuf;
 379                 data.flags |= DB_DBT_PARTIAL;
 380
 381                 BDB_ID2DISK( id, &nid );
 382                 rc = cursor->c_get( cursor, &key, &data, DB_SET );
 383                 if ( rc ) {
 384                         rc = LDAP_OTHER;
 385                         goto done;
 386                 }
 387         }
 388
 389         /* Get the header */
 390         dptr = eh.bv.bv_val;
 391         eh.bv.bv_val = ehbuf;
 392         eh.bv.bv_len = data.size;
 393         rc = entry_header( &eh );
 394         eoff = eh.data - eh.bv.bv_val;
 395         eh.bv.bv_val = dptr;
 396         if ( rc ) {
 397                 rc = LDAP_OTHER;
 398                 goto done;
 399         }
 400
 401         /* Get the size */
 402         data.flags &= ~DB_DBT_PARTIAL;
 403         data.ulen = 0;
 404         rc = cursor->c_get( cursor, &key, &data, DB_CURRENT );
 405         if ( rc != DB_BUFFER_SMALL ) {
 406                 rc = LDAP_OTHER;
 407                 goto done;
 408         }
 409
 410         /* Allocate a block and retrieve the data */
 411         eh.bv.bv_len = eh.nvals * sizeof( struct berval ) + data.size;
 412         eh.bv.bv_val = ch_realloc( eh.bv.bv_val, eh.bv.bv_len );
 413         eh.data = eh.bv.bv_val + eh.nvals * sizeof( struct berval );
 414         data.data = eh.data;
 415         data.ulen = data.size;
 416
 417         /* Skip past already parsed nattr/nvals */
 418         eh.data += eoff;
 419
 420         rc = cursor->c_get( cursor, &key, &data, DB_CURRENT );
 421         if ( rc ) {
 422                 rc = LDAP_OTHER;
 423                 goto done;
 424         }
 425
 426 #ifndef BDB_HIER
 427         /* TODO: handle BDB_HIER accordingly */
 428         if ( tool_base != NULL ) {
 429                 struct berval ndn;
 430                 entry_decode_dn( &eh, NULL, &ndn );
 431
 432                 if ( !dnIsSuffixScope( &ndn, tool_base, tool_scope ) ) {
 433                         return LDAP_NO_SUCH_OBJECT;
 434                 }
 435         }
 436 #endif
 437
 438 #ifdef SLAP_ZONE_ALLOC
 439         /* FIXME: will add ctx later */
 440         rc = entry_decode( &eh, &e, NULL );
 441 #else
 442         rc = entry_decode( &eh, &e );
 443 #endif
 444
 445         if( rc == LDAP_SUCCESS ) {
 446                 e->e_id = id;
 447 #ifdef BDB_HIER
 448                 if ( slapMode & SLAP_TOOL_READONLY ) {
 449                         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
 450                         EntryInfo *ei = NULL;
 451                         Operation op = {0};
 452                         Opheader ohdr = {0};
 453
 454                         op.o_hdr = &ohdr;
 455                         op.o_bd = be;
 456                         op.o_tmpmemctx = NULL;
 457                         op.o_tmpmfuncs = &ch_mfuncs;
 458
 459                         rc = bdb_cache_find_parent( &op, bdb->bi_cache.c_txn, id, &ei );
 460                         if ( rc == LDAP_SUCCESS ) {
 461                                 bdb_cache_entryinfo_unlock( ei );
 462                                 e->e_private = ei;
 463                                 ei->bei_e = e;
 464                                 bdb_fix_dn( e, 0 );
 465                                 ei->bei_e = NULL;
 466                                 e->e_private = NULL;
 467                         }
 468                 }
 469 #endif
 470         }
 471 done:
 472         if ( e != NULL ) {
 473                 *ep = e;
 474         }
 475
 476         return rc;
 477 }
 478
 479 Entry*
 480 bdb_tool_entry_get( BackendDB *be, ID id )
 481 {
 482         Entry *e = NULL;
 483
 484         (void)bdb_tool_entry_get_int( be, id, &e );
 485         return e;
 486 }
 487
 488 static int bdb_tool_next_id(
 489         Operation *op,
 490         DB_TXN *tid,
 491         Entry *e,
 492         struct berval *text,
 493         int hole )
 494 {
 495         struct berval dn = e->e_name;
 496         struct berval ndn = e->e_nname;
 497         struct berval pdn, npdn;
 498         EntryInfo *ei = NULL, eidummy;
 499         int rc;
 500
 501         if (ndn.bv_len == 0) {
 502                 e->e_id = 0;
 503                 return 0;
 504         }
 505
 506         rc = bdb_cache_find_ndn( op, tid, &ndn, &ei );
 507         if ( ei ) bdb_cache_entryinfo_unlock( ei );
 508         if ( rc == DB_NOTFOUND ) {
 509                 if ( !be_issuffix( op->o_bd, &ndn ) ) {
 510                         ID eid = e->e_id;
 511                         dnParent( &dn, &pdn );
 512                         dnParent( &ndn, &npdn );
 513                         e->e_name = pdn;
 514                         e->e_nname = npdn;
 515                         rc = bdb_tool_next_id( op, tid, e, text, 1 );
 516                         e->e_name = dn;
 517                         e->e_nname = ndn;
 518                         if ( rc ) {
 519                                 return rc;
 520                         }
 521                         /* If parent didn't exist, it was created just now
 522                          * and its ID is now in e->e_id. Make sure the current
 523                          * entry gets added under the new parent ID.
 524                          */
 525                         if ( eid != e->e_id ) {
 526                                 eidummy.bei_id = e->e_id;
 527                                 ei = &eidummy;
 528                         }
 529                 }
 530                 rc = bdb_next_id( op->o_bd, &e->e_id );
 531                 if ( rc ) {
 532                         snprintf( text->bv_val, text->bv_len,
 533                                 "next_id failed: %s (%d)",
 534                                 db_strerror(rc), rc );
 535                 Debug( LDAP_DEBUG_ANY,
 536                         "=> bdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
 537                         return rc;
 538                 }
 539                 rc = bdb_dn2id_add( op, tid, ei, e );
 540                 if ( rc ) {
 541                         snprintf( text->bv_val, text->bv_len,
 542                                 "dn2id_add failed: %s (%d)",
 543                                 db_strerror(rc), rc );
 544                 Debug( LDAP_DEBUG_ANY,
 545                         "=> bdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
 546                 } else if ( hole ) {
 547                         if ( nholes == nhmax - 1 ) {
 548                                 if ( holes == hbuf ) {
 549                                         holes = ch_malloc( nhmax * sizeof(dn_id) * 2 );
 550                                         AC_MEMCPY( holes, hbuf, sizeof(hbuf) );
 551                                 } else {
 552                                         holes = ch_realloc( holes, nhmax * sizeof(dn_id) * 2 );
 553                                 }
 554                                 nhmax *= 2;
 555                         }
 556                         ber_dupbv( &holes[nholes].dn, &ndn );
 557                         holes[nholes++].id = e->e_id;
 558                 }
 559         } else if ( !hole ) {
 560                 unsigned i, j;
 561
 562                 e->e_id = ei->bei_id;
 563
 564                 for ( i=0; i<nholes; i++) {
 565                         if ( holes[i].id == e->e_id ) {
 566                                 free(holes[i].dn.bv_val);
 567                                 for (j=i;j<nholes;j++) holes[j] = holes[j+1];
 568                                 holes[j].id = 0;
 569                                 nholes--;
 570                                 break;
 571                         } else if ( holes[i].id > e->e_id ) {
 572                                 break;
 573                         }
 574                 }
 575         }
 576         return rc;
 577 }
 578
 579 static int
 580 bdb_tool_index_add(
 581         Operation *op,
 582         DB_TXN *txn,
 583         Entry *e )
 584 {
 585         struct bdb_info *bdb = (struct bdb_info *) op->o_bd->be_private;
 586
 587         if ( !bdb->bi_nattrs )
 588                 return 0;
 589
 590         if ( bdb_tool_threads > 1 ) {
 591                 IndexRec *ir;
 592                 int i, rc;
 593                 Attribute *a;
 594
 595                 ir = bdb_tool_index_rec;
 596                 memset(ir, 0, bdb->bi_nattrs * sizeof( IndexRec ));
 597
 598                 for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
 599                         rc = bdb_index_recset( bdb, a, a->a_desc->ad_type,
 600                                 &a->a_desc->ad_tags, ir );
 601                         if ( rc )
 602                                 return rc;
 603                 }
 604                 bdb_tool_ix_id = e->e_id;
 605                 bdb_tool_ix_op = op;
 606                 ldap_pvt_thread_mutex_lock( &bdb_tool_index_mutex );
 607                 /* Wait for all threads to be ready */
 608                 while ( bdb_tool_index_tcount > 0 ) {
 609                         ldap_pvt_thread_cond_wait( &bdb_tool_index_cond_main,
 610                                 &bdb_tool_index_mutex );
 611                 }
 612                 for ( i=1; i<bdb_tool_threads; i++ )
 613                         bdb_tool_index_threads[i] = LDAP_BUSY;
 614                 bdb_tool_index_tcount = bdb_tool_threads - 1;
 615                 ldap_pvt_thread_cond_broadcast( &bdb_tool_index_cond_work );
 616                 ldap_pvt_thread_mutex_unlock( &bdb_tool_index_mutex );
 617                 rc = bdb_index_recrun( op, bdb, ir, e->e_id, 0 );
 618                 if ( rc )
 619                         return rc;
 620                 ldap_pvt_thread_mutex_lock( &bdb_tool_index_mutex );
 621                 for ( i=1; i<bdb_tool_threads; i++ ) {
 622                         if ( bdb_tool_index_threads[i] == LDAP_BUSY ) {
 623                                 ldap_pvt_thread_cond_wait( &bdb_tool_index_cond_main,
 624                                         &bdb_tool_index_mutex );
 625                                 i--;
 626                                 continue;
 627                         }
 628                         if ( bdb_tool_index_threads[i] ) {
 629                                 rc = bdb_tool_index_threads[i];
 630                                 break;
 631                         }
 632                 }
 633                 ldap_pvt_thread_mutex_unlock( &bdb_tool_index_mutex );
 634                 return rc;
 635         } else {
 636                 return bdb_index_entry_add( op, txn, e );
 637         }
 638 }
 639
 640 ID bdb_tool_entry_put(
 641         BackendDB *be,
 642         Entry *e,
 643         struct berval *text )
 644 {
 645         int rc;
 646         struct bdb_info *bdb;
 647         DB_TXN *tid = NULL;
 648         Operation op = {0};
 649         Opheader ohdr = {0};
 650
 651         assert( be != NULL );
 652         assert( slapMode & SLAP_TOOL_MODE );
 653
 654         assert( text != NULL );
 655         assert( text->bv_val != NULL );
 656         assert( text->bv_val[0] == '\0' );      /* overconservative? */
 657
 658         Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(bdb_tool_entry_put)
 659                 "( %ld, \"%s\" )\n", (long) e->e_id, e->e_dn, 0 );
 660
 661         bdb = (struct bdb_info *) be->be_private;
 662
 663         if (! (slapMode & SLAP_TOOL_QUICK)) {
 664         rc = TXN_BEGIN( bdb->bi_dbenv, NULL, &tid,
 665                 bdb->bi_db_opflags );
 666         if( rc != 0 ) {
 667                 snprintf( text->bv_val, text->bv_len,
 668                         "txn_begin failed: %s (%d)",
 669                         db_strerror(rc), rc );
 670                 Debug( LDAP_DEBUG_ANY,
 671                         "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n",
 672                          text->bv_val, 0, 0 );
 673                 return NOID;
 674         }
 675         Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_put) ": txn id: %x\n",
 676                 tid->id(tid), 0, 0 );
 677         }
 678
 679         op.o_hdr = &ohdr;
 680         op.o_bd = be;
 681         op.o_tmpmemctx = NULL;
 682         op.o_tmpmfuncs = &ch_mfuncs;
 683
 684         /* add dn2id indices */
 685         rc = bdb_tool_next_id( &op, tid, e, text, 0 );
 686         if( rc != 0 ) {
 687                 goto done;
 688         }
 689
 690 #ifdef USE_TRICKLE
 691         if (( slapMode & SLAP_TOOL_QUICK ) && (( e->e_id & 0xfff ) == 0xfff )) {
 692                 ldap_pvt_thread_cond_signal( &bdb_tool_trickle_cond );
 693         }
 694 #endif
 695
 696         if ( !bdb->bi_linear_index )
 697                 rc = bdb_tool_index_add( &op, tid, e );
 698         if( rc != 0 ) {
 699                 snprintf( text->bv_val, text->bv_len,
 700                                 "index_entry_add failed: %s (%d)",
 701                                 rc == LDAP_OTHER ? "Internal error" :
 702                                 db_strerror(rc), rc );
 703                 Debug( LDAP_DEBUG_ANY,
 704                         "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n",
 705                         text->bv_val, 0, 0 );
 706                 goto done;
 707         }
 708
 709         /* id2entry index */
 710         rc = bdb_id2entry_add( be, tid, e );
 711         if( rc != 0 ) {
 712                 snprintf( text->bv_val, text->bv_len,
 713                                 "id2entry_add failed: %s (%d)",
 714                                 db_strerror(rc), rc );
 715                 Debug( LDAP_DEBUG_ANY,
 716                         "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n",
 717                         text->bv_val, 0, 0 );
 718                 goto done;
 719         }
 720
 721 done:
 722         if( rc == 0 ) {
 723                 if ( !( slapMode & SLAP_TOOL_QUICK )) {
 724                 rc = TXN_COMMIT( tid, 0 );
 725                 if( rc != 0 ) {
 726                         snprintf( text->bv_val, text->bv_len,
 727                                         "txn_commit failed: %s (%d)",
 728                                         db_strerror(rc), rc );
 729                         Debug( LDAP_DEBUG_ANY,
 730                                 "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n",
 731                                 text->bv_val, 0, 0 );
 732                         e->e_id = NOID;
 733                 }
 734                 }
 735
 736         } else {
 737                 if ( !( slapMode & SLAP_TOOL_QUICK )) {
 738                 TXN_ABORT( tid );
 739                 snprintf( text->bv_val, text->bv_len,
 740                         "txn_aborted! %s (%d)",
 741                         rc == LDAP_OTHER ? "Internal error" :
 742                         db_strerror(rc), rc );
 743                 Debug( LDAP_DEBUG_ANY,
 744                         "=> " LDAP_XSTRING(bdb_tool_entry_put) ": %s\n",
 745                         text->bv_val, 0, 0 );
 746                 }
 747                 e->e_id = NOID;
 748         }
 749
 750         return e->e_id;
 751 }
 752
 753 int bdb_tool_entry_reindex(
 754         BackendDB *be,
 755         ID id,
 756         AttributeDescription **adv )
 757 {
 758         struct bdb_info *bi = (struct bdb_info *) be->be_private;
 759         int rc;
 760         Entry *e;
 761         DB_TXN *tid = NULL;
 762         Operation op = {0};
 763         Opheader ohdr = {0};
 764
 765         Debug( LDAP_DEBUG_ARGS,
 766                 "=> " LDAP_XSTRING(bdb_tool_entry_reindex) "( %ld )\n",
 767                 (long) id, 0, 0 );
 768         assert( tool_base == NULL );
 769         assert( tool_filter == NULL );
 770
 771         /* No indexes configured, nothing to do. Could return an
 772          * error here to shortcut things.
 773          */
 774         if (!bi->bi_attrs) {
 775                 return 0;
 776         }
 777
 778         /* Check for explicit list of attrs to index */
 779         if ( adv ) {
 780                 int i, j, n;
 781
 782                 if ( bi->bi_attrs[0]->ai_desc != adv[0] ) {
 783                         /* count */
 784                         for ( n = 0; adv[n]; n++ ) ;
 785
 786                         /* insertion sort */
 787                         for ( i = 0; i < n; i++ ) {
 788                                 AttributeDescription *ad = adv[i];
 789                                 for ( j = i-1; j>=0; j--) {
 790                                         if ( SLAP_PTRCMP( adv[j], ad ) <= 0 ) break;
 791                                         adv[j+1] = adv[j];
 792                                 }
 793                                 adv[j+1] = ad;
 794                         }
 795                 }
 796
 797                 for ( i = 0; adv[i]; i++ ) {
 798                         if ( bi->bi_attrs[i]->ai_desc != adv[i] ) {
 799                                 for ( j = i+1; j < bi->bi_nattrs; j++ ) {
 800                                         if ( bi->bi_attrs[j]->ai_desc == adv[i] ) {
 801                                                 AttrInfo *ai = bi->bi_attrs[i];
 802                                                 bi->bi_attrs[i] = bi->bi_attrs[j];
 803                                                 bi->bi_attrs[j] = ai;
 804                                                 break;
 805                                         }
 806                                 }
 807                                 if ( j == bi->bi_nattrs ) {
 808                                         Debug( LDAP_DEBUG_ANY,
 809                                                 LDAP_XSTRING(bdb_tool_entry_reindex)
 810                                                 ": no index configured for %s\n",
 811                                                 adv[i]->ad_cname.bv_val, 0, 0 );
 812                                         return -1;
 813                                 }
 814                         }
 815                 }
 816                 bi->bi_nattrs = i;
 817         }
 818
 819         /* Get the first attribute to index */
 820         if (bi->bi_linear_index && !index_nattrs) {
 821                 index_nattrs = bi->bi_nattrs - 1;
 822                 bi->bi_nattrs = 1;
 823         }
 824
 825         e = bdb_tool_entry_get( be, id );
 826
 827         if( e == NULL ) {
 828                 Debug( LDAP_DEBUG_ANY,
 829                         LDAP_XSTRING(bdb_tool_entry_reindex)
 830                         ": could not locate id=%ld\n",
 831                         (long) id, 0, 0 );
 832                 return -1;
 833         }
 834
 835         op.o_hdr = &ohdr;
 836         op.o_bd = be;
 837         op.o_tmpmemctx = NULL;
 838         op.o_tmpmfuncs = &ch_mfuncs;
 839
 840         if (! (slapMode & SLAP_TOOL_QUICK)) {
 841         rc = TXN_BEGIN( bi->bi_dbenv, NULL, &tid, bi->bi_db_opflags );
 842         if( rc != 0 ) {
 843                 Debug( LDAP_DEBUG_ANY,
 844                         "=> " LDAP_XSTRING(bdb_tool_entry_reindex) ": "
 845                         "txn_begin failed: %s (%d)\n",
 846                         db_strerror(rc), rc, 0 );
 847                 goto done;
 848         }
 849         Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_reindex) ": txn id: %x\n",
 850                 tid->id(tid), 0, 0 );
 851         }
 852
 853         /*
 854          * just (re)add them for now
 855          * assume that some other routine (not yet implemented)
 856          * will zap index databases
 857          *
 858          */
 859
 860         Debug( LDAP_DEBUG_TRACE,
 861                 "=> " LDAP_XSTRING(bdb_tool_entry_reindex) "( %ld, \"%s\" )\n",
 862                 (long) id, e->e_dn, 0 );
 863
 864         rc = bdb_tool_index_add( &op, tid, e );
 865
 866 done:
 867         if( rc == 0 ) {
 868                 if (! (slapMode & SLAP_TOOL_QUICK)) {
 869                 rc = TXN_COMMIT( tid, 0 );
 870                 if( rc != 0 ) {
 871                         Debug( LDAP_DEBUG_ANY,
 872                                 "=> " LDAP_XSTRING(bdb_tool_entry_reindex)
 873                                 ": txn_commit failed: %s (%d)\n",
 874                                 db_strerror(rc), rc, 0 );
 875                         e->e_id = NOID;
 876                 }
 877                 }
 878
 879         } else {
 880                 if (! (slapMode & SLAP_TOOL_QUICK)) {
 881                 TXN_ABORT( tid );
 882                 Debug( LDAP_DEBUG_ANY,
 883                         "=> " LDAP_XSTRING(bdb_tool_entry_reindex)
 884                         ": txn_aborted! %s (%d)\n",
 885                         db_strerror(rc), rc, 0 );
 886                 }
 887                 e->e_id = NOID;
 888         }
 889         bdb_entry_release( &op, e, 0 );
 890
 891         return rc;
 892 }
 893
 894 ID bdb_tool_entry_modify(
 895         BackendDB *be,
 896         Entry *e,
 897         struct berval *text )
 898 {
 899         int rc;
 900         struct bdb_info *bdb;
 901         DB_TXN *tid = NULL;
 902         Operation op = {0};
 903         Opheader ohdr = {0};
 904
 905         assert( be != NULL );
 906         assert( slapMode & SLAP_TOOL_MODE );
 907
 908         assert( text != NULL );
 909         assert( text->bv_val != NULL );
 910         assert( text->bv_val[0] == '\0' );      /* overconservative? */
 911
 912         assert ( e->e_id != NOID );
 913
 914         Debug( LDAP_DEBUG_TRACE,
 915                 "=> " LDAP_XSTRING(bdb_tool_entry_modify) "( %ld, \"%s\" )\n",
 916                 (long) e->e_id, e->e_dn, 0 );
 917
 918         bdb = (struct bdb_info *) be->be_private;
 919
 920         if (! (slapMode & SLAP_TOOL_QUICK)) {
 921                 if( cursor ) {
 922                         cursor->c_close( cursor );
 923                         cursor = NULL;
 924                 }
 925                 rc = TXN_BEGIN( bdb->bi_dbenv, NULL, &tid,
 926                         bdb->bi_db_opflags );
 927                 if( rc != 0 ) {
 928                         snprintf( text->bv_val, text->bv_len,
 929                                 "txn_begin failed: %s (%d)",
 930                                 db_strerror(rc), rc );
 931                         Debug( LDAP_DEBUG_ANY,
 932                                 "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n",
 933                                  text->bv_val, 0, 0 );
 934                         return NOID;
 935                 }
 936                 Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_tool_entry_modify) ": txn id: %x\n",
 937                         tid->id(tid), 0, 0 );
 938         }
 939
 940         op.o_hdr = &ohdr;
 941         op.o_bd = be;
 942         op.o_tmpmemctx = NULL;
 943         op.o_tmpmfuncs = &ch_mfuncs;
 944
 945         /* id2entry index */
 946         rc = bdb_id2entry_update( be, tid, e );
 947         if( rc != 0 ) {
 948                 snprintf( text->bv_val, text->bv_len,
 949                                 "id2entry_add failed: %s (%d)",
 950                                 db_strerror(rc), rc );
 951                 Debug( LDAP_DEBUG_ANY,
 952                         "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n",
 953                         text->bv_val, 0, 0 );
 954                 goto done;
 955         }
 956
 957 done:
 958         if( rc == 0 ) {
 959                 if (! (slapMode & SLAP_TOOL_QUICK)) {
 960                 rc = TXN_COMMIT( tid, 0 );
 961                 if( rc != 0 ) {
 962                         snprintf( text->bv_val, text->bv_len,
 963                                         "txn_commit failed: %s (%d)",
 964                                         db_strerror(rc), rc );
 965                         Debug( LDAP_DEBUG_ANY,
 966                                 "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": "
 967                                 "%s\n", text->bv_val, 0, 0 );
 968                         e->e_id = NOID;
 969                 }
 970                 }
 971
 972         } else {
 973                 if (! (slapMode & SLAP_TOOL_QUICK)) {
 974                 TXN_ABORT( tid );
 975                 snprintf( text->bv_val, text->bv_len,
 976                         "txn_aborted! %s (%d)",
 977                         db_strerror(rc), rc );
 978                 Debug( LDAP_DEBUG_ANY,
 979                         "=> " LDAP_XSTRING(bdb_tool_entry_modify) ": %s\n",
 980                         text->bv_val, 0, 0 );
 981                 }
 982                 e->e_id = NOID;
 983         }
 984
 985         return e->e_id;
 986 }
 987
 988 #ifdef BDB_TOOL_IDL_CACHING
 989 static int
 990 bdb_tool_idl_cmp( const void *v1, const void *v2 )
 991 {
 992         const bdb_tool_idl_cache *c1 = v1, *c2 = v2;
 993         int rc;
 994
 995         if (( rc = c1->kstr.bv_len - c2->kstr.bv_len )) return rc;
 996         return memcmp( c1->kstr.bv_val, c2->kstr.bv_val, c1->kstr.bv_len );
 997 }
 998
 999 static int
1000 bdb_tool_idl_flush_one( void *v1, void *arg )
1001 {
1002         bdb_tool_idl_cache *ic = v1;
1003         DB *db = arg;
1004         struct bdb_info *bdb = bdb_tool_info;
1005         bdb_tool_idl_cache_entry *ice;
1006         DBC *curs;
1007         DBT key, data;
1008         int i, rc;
1009         ID id, nid;
1010
1011         /* Freshly allocated, ignore it */
1012         if ( !ic->head && ic->count <= BDB_IDL_DB_SIZE ) {
1013                 return 0;
1014         }
1015
1016         rc = db->cursor( db, NULL, &curs, 0 );
1017         if ( rc )
1018                 return -1;
1019
1020         DBTzero( &key );
1021         DBTzero( &data );
1022
1023         bv2DBT( &ic->kstr, &key );
1024
1025         data.size = data.ulen = sizeof( ID );
1026         data.flags = DB_DBT_USERMEM;
1027         data.data = &nid;
1028
1029         rc = curs->c_get( curs, &key, &data, DB_SET );
1030         /* If key already exists and we're writing a range... */
1031         if ( rc == 0 && ic->count > BDB_IDL_DB_SIZE ) {
1032                 /* If it's not currently a range, must delete old info */
1033                 if ( nid ) {
1034                         /* Skip lo */
1035                         while ( curs->c_get( curs, &key, &data, DB_NEXT_DUP ) == 0 )
1036                                 curs->c_del( curs, 0 );
1037
1038                         nid = 0;
1039                         /* Store range marker */
1040                         curs->c_put( curs, &key, &data, DB_KEYFIRST );
1041                 } else {
1042
1043                         /* Skip lo */
1044                         rc = curs->c_get( curs, &key, &data, DB_NEXT_DUP );
1045
1046                         /* Get hi */
1047                         rc = curs->c_get( curs, &key, &data, DB_NEXT_DUP );
1048
1049                         /* Delete hi */
1050                         curs->c_del( curs, 0 );
1051                 }
1052                 BDB_ID2DISK( ic->last, &nid );
1053                 curs->c_put( curs, &key, &data, DB_KEYLAST );
1054                 rc = 0;
1055         } else if ( rc && rc != DB_NOTFOUND ) {
1056                 rc = -1;
1057         } else if ( ic->count > BDB_IDL_DB_SIZE ) {
1058                 /* range, didn't exist before */
1059                 nid = 0;
1060                 rc = curs->c_put( curs, &key, &data, DB_KEYLAST );
1061                 if ( rc == 0 ) {
1062                         BDB_ID2DISK( ic->first, &nid );
1063                         rc = curs->c_put( curs, &key, &data, DB_KEYLAST );
1064                         if ( rc == 0 ) {
1065                                 BDB_ID2DISK( ic->last, &nid );
1066                                 rc = curs->c_put( curs, &key, &data, DB_KEYLAST );
1067                         }
1068                 }
1069                 if ( rc ) {
1070                         rc = -1;
1071                 }
1072         } else {
1073                 int n;
1074
1075                 /* Just a normal write */
1076                 rc = 0;
1077                 for ( ice = ic->head, n=0; ice; ice = ice->next, n++ ) {
1078                         int end;
1079                         if ( ice->next ) {
1080                                 end = IDBLOCK;
1081                         } else {
1082                                 end = ic->count & (IDBLOCK-1);
1083                                 if ( !end )
1084                                         end = IDBLOCK;
1085                         }
1086                         for ( i=0; i<end; i++ ) {
1087                                 if ( !ice->ids[i] ) continue;
1088                                 BDB_ID2DISK( ice->ids[i], &nid );
1089                                 rc = curs->c_put( curs, &key, &data, DB_NODUPDATA );
1090                                 if ( rc ) {
1091                                         if ( rc == DB_KEYEXIST ) {
1092                                                 rc = 0;
1093                                                 continue;
1094                                         }
1095                                         rc = -1;
1096                                         break;
1097                                 }
1098                         }
1099                         if ( rc ) {
1100                                 rc = -1;
1101                                 break;
1102                         }
1103                 }
1104                 if ( ic->head ) {
1105                         ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
1106                         ic->tail->next = bdb_tool_idl_free_list;
1107                         bdb_tool_idl_free_list = ic->head;
1108                         bdb->bi_idl_cache_size -= n;
1109                         ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
1110                 }
1111         }
1112         if ( ic != db->app_private ) {
1113                 ch_free( ic );
1114         } else {
1115                 ic->head = ic->tail = NULL;
1116         }
1117         curs->c_close( curs );
1118         return rc;
1119 }
1120
1121 static int
1122 bdb_tool_idl_flush_db( DB *db, bdb_tool_idl_cache *ic )
1123 {
1124         Avlnode *root = db->app_private;
1125         int rc;
1126
1127         db->app_private = ic;
1128         rc = avl_apply( root, bdb_tool_idl_flush_one, db, -1, AVL_INORDER );
1129         avl_free( root, NULL );
1130         db->app_private = NULL;
1131         if ( rc != -1 )
1132                 rc = 0;
1133         return rc;
1134 }
1135
1136 static int
1137 bdb_tool_idl_flush( BackendDB *be )
1138 {
1139         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
1140         DB *db;
1141         Avlnode *root;
1142         int i, rc = 0;
1143
1144         for ( i=BDB_NDB; i < bdb->bi_ndatabases; i++ ) {
1145                 db = bdb->bi_databases[i]->bdi_db;
1146                 if ( !db->app_private ) continue;
1147                 rc = bdb_tool_idl_flush_db( db, NULL );
1148                 if ( rc )
1149                         break;
1150         }
1151         if ( !rc ) {
1152                 bdb->bi_idl_cache_size = 0;
1153         }
1154         return rc;
1155 }
1156
1157 int bdb_tool_idl_add(
1158         BackendDB *be,
1159         DB *db,
1160         DB_TXN *txn,
1161         DBT *key,
1162         ID id )
1163 {
1164         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
1165         bdb_tool_idl_cache *ic, itmp;
1166         bdb_tool_idl_cache_entry *ice;
1167         int rc;
1168
1169         if ( !bdb->bi_idl_cache_max_size )
1170                 return bdb_idl_insert_key( be, db, txn, key, id );
1171
1172         DBT2bv( key, &itmp.kstr );
1173
1174         ic = avl_find( (Avlnode *)db->app_private, &itmp, bdb_tool_idl_cmp );
1175
1176         /* No entry yet, create one */
1177         if ( !ic ) {
1178                 DBC *curs;
1179                 DBT data;
1180                 ID nid;
1181                 int rc;
1182
1183                 ic = ch_malloc( sizeof( bdb_tool_idl_cache ) + itmp.kstr.bv_len );
1184                 ic->kstr.bv_len = itmp.kstr.bv_len;
1185                 ic->kstr.bv_val = (char *)(ic+1);
1186                 AC_MEMCPY( ic->kstr.bv_val, itmp.kstr.bv_val, ic->kstr.bv_len );
1187                 ic->head = ic->tail = NULL;
1188                 ic->last = 0;
1189                 ic->count = 0;
1190                 avl_insert( (Avlnode **)&db->app_private, ic, bdb_tool_idl_cmp,
1191                         avl_dup_error );
1192
1193                 /* load existing key count here */
1194                 rc = db->cursor( db, NULL, &curs, 0 );
1195                 if ( rc ) return rc;
1196
1197                 data.ulen = sizeof( ID );
1198                 data.flags = DB_DBT_USERMEM;
1199                 data.data = &nid;
1200                 rc = curs->c_get( curs, key, &data, DB_SET );
1201                 if ( rc == 0 ) {
1202                         if ( nid == 0 ) {
1203                                 ic->count = BDB_IDL_DB_SIZE+1;
1204                         } else {
1205                                 db_recno_t count;
1206
1207                                 curs->c_count( curs, &count, 0 );
1208                                 ic->count = count;
1209                                 BDB_DISK2ID( &nid, &ic->first );
1210                         }
1211                 }
1212                 curs->c_close( curs );
1213         }
1214         /* are we a range already? */
1215         if ( ic->count > BDB_IDL_DB_SIZE ) {
1216                 ic->last = id;
1217                 return 0;
1218         /* Are we at the limit, and converting to a range? */
1219         } else if ( ic->count == BDB_IDL_DB_SIZE ) {
1220                 int n;
1221                 for ( ice = ic->head, n=0; ice; ice = ice->next, n++ )
1222                         /* counting */ ;
1223                 if ( n ) {
1224                         ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
1225                         ic->tail->next = bdb_tool_idl_free_list;
1226                         bdb_tool_idl_free_list = ic->head;
1227                         bdb->bi_idl_cache_size -= n;
1228                         ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
1229                 }
1230                 ic->head = ic->tail = NULL;
1231                 ic->last = id;
1232                 ic->count++;
1233                 return 0;
1234         }
1235         /* No free block, create that too */
1236         if ( !ic->tail || ( ic->count & (IDBLOCK-1)) == 0) {
1237                 ice = NULL;
1238                 ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
1239                 if ( bdb->bi_idl_cache_size >= bdb->bi_idl_cache_max_size ) {
1240                         ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
1241                         rc = bdb_tool_idl_flush_db( db, ic );
1242                         if ( rc )
1243                                 return rc;
1244                         avl_insert( (Avlnode **)&db->app_private, ic, bdb_tool_idl_cmp,
1245                                 avl_dup_error );
1246                         ldap_pvt_thread_mutex_lock( &bdb->bi_idl_tree_lrulock );
1247                 }
1248                 bdb->bi_idl_cache_size++;
1249                 if ( bdb_tool_idl_free_list ) {
1250                         ice = bdb_tool_idl_free_list;
1251                         bdb_tool_idl_free_list = ice->next;
1252                 }
1253                 ldap_pvt_thread_mutex_unlock( &bdb->bi_idl_tree_lrulock );
1254                 if ( !ice ) {
1255                         ice = ch_malloc( sizeof( bdb_tool_idl_cache_entry ));
1256                 }
1257                 memset( ice, 0, sizeof( *ice ));
1258                 if ( !ic->head ) {
1259                         ic->head = ice;
1260                 } else {
1261                         ic->tail->next = ice;
1262                 }
1263                 ic->tail = ice;
1264                 if ( !ic->count )
1265                         ic->first = id;
1266         }
1267         ice = ic->tail;
1268         ice->ids[ ic->count & (IDBLOCK-1) ] = id;
1269         ic->count++;
1270
1271         return 0;
1272 }
1273 #endif
1274
1275 #ifdef USE_TRICKLE
1276 static void *
1277 bdb_tool_trickle_task( void *ctx, void *ptr )
1278 {
1279         DB_ENV *env = ptr;
1280         int wrote;
1281
1282         ldap_pvt_thread_mutex_lock( &bdb_tool_trickle_mutex );
1283         bdb_tool_trickle_active = 1;
1284         ldap_pvt_thread_cond_signal( &bdb_tool_trickle_cond_end );
1285         while ( 1 ) {
1286                 ldap_pvt_thread_cond_wait( &bdb_tool_trickle_cond,
1287                         &bdb_tool_trickle_mutex );
1288                 if ( slapd_shutdown )
1289                         break;
1290                 env->memp_trickle( env, 30, &wrote );
1291         }
1292         bdb_tool_trickle_active = 0;
1293         ldap_pvt_thread_cond_signal( &bdb_tool_trickle_cond_end );
1294         ldap_pvt_thread_mutex_unlock( &bdb_tool_trickle_mutex );
1295
1296         return NULL;
1297 }
1298 #endif
1299
1300 static void *
1301 bdb_tool_index_task( void *ctx, void *ptr )
1302 {
1303         int base = *(int *)ptr;
1304
1305         free( ptr );
1306         while ( 1 ) {
1307                 ldap_pvt_thread_mutex_lock( &bdb_tool_index_mutex );
1308                 bdb_tool_index_tcount--;
1309                 if ( !bdb_tool_index_tcount )
1310                         ldap_pvt_thread_cond_signal( &bdb_tool_index_cond_main );
1311                 ldap_pvt_thread_cond_wait( &bdb_tool_index_cond_work,
1312                         &bdb_tool_index_mutex );
1313                 if ( slapd_shutdown ) {
1314                         bdb_tool_index_tcount--;
1315                         if ( !bdb_tool_index_tcount )
1316                                 ldap_pvt_thread_cond_signal( &bdb_tool_index_cond_main );
1317                         ldap_pvt_thread_mutex_unlock( &bdb_tool_index_mutex );
1318                         break;
1319                 }
1320                 ldap_pvt_thread_mutex_unlock( &bdb_tool_index_mutex );
1321
1322                 bdb_tool_index_threads[base] = bdb_index_recrun( bdb_tool_ix_op,
1323                         bdb_tool_info, bdb_tool_index_rec, bdb_tool_ix_id, base );
1324         }
1325
1326         return NULL;
1327 }