]> git.sur5r.net Git - openldap/blob - servers/slapd/back-mdb/tools.c
79ef877f43334f0b51b847e82a1931996533cc51
[openldap] / servers / slapd / back-mdb / 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 2011 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-mdb.h"
25 #include "idl.h"
26
27 static int mdb_tool_idl_flush( BackendDB *be, MDB_txn *txn );
28
29 #define IDBLOCK 1024
30
31 typedef struct mdb_tool_idl_cache_entry {
32         struct mdb_tool_idl_cache_entry *next;
33         ID ids[IDBLOCK];
34 } mdb_tool_idl_cache_entry;
35
36 typedef struct mdb_tool_idl_cache {
37         struct berval kstr;
38         mdb_tool_idl_cache_entry *head, *tail;
39         ID first, last;
40         int count;
41 } mdb_tool_idl_cache;
42
43 static mdb_tool_idl_cache_entry *mdb_tool_idl_free_list;
44 static Avlnode *mdb_tool_roots[MDB_INDICES];
45
46 static MDB_txn *txn = NULL, *txi = NULL;
47 static MDB_cursor *cursor = NULL, *idcursor = NULL;
48 static MDB_val key, data;
49 static ID previd = NOID;
50
51 typedef struct dn_id {
52         ID id;
53         struct berval dn;
54 } dn_id;
55
56 #define HOLE_SIZE       4096
57 static dn_id hbuf[HOLE_SIZE], *holes = hbuf;
58 static unsigned nhmax = HOLE_SIZE;
59 static unsigned nholes;
60
61 static struct berval    *tool_base;
62 static int              tool_scope;
63 static Filter           *tool_filter;
64 static Entry            *tool_next_entry;
65
66 #if 0
67 static ID mdb_tool_ix_id;
68 static Operation *mdb_tool_ix_op;
69 static int *mdb_tool_index_threads, mdb_tool_index_tcount;
70 static void *mdb_tool_index_rec;
71 static struct mdb_info *mdb_tool_info;
72 static ldap_pvt_thread_mutex_t mdb_tool_index_mutex;
73 static ldap_pvt_thread_cond_t mdb_tool_index_cond_main;
74 static ldap_pvt_thread_cond_t mdb_tool_index_cond_work;
75 static void * mdb_tool_index_task( void *ctx, void *ptr );
76 #endif
77
78 static int      mdb_writes, mdb_writes_per_commit;
79
80 static int
81 mdb_tool_entry_get_int( BackendDB *be, ID id, Entry **ep );
82
83 int mdb_tool_entry_open(
84         BackendDB *be, int mode )
85 {
86         /* In Quick mode, commit once per 1000 entries */
87         mdb_writes = 0;
88         if ( slapMode & SLAP_TOOL_QUICK )
89                 mdb_writes_per_commit = 1000;
90         else
91                 mdb_writes_per_commit = 1;
92
93 #if 0
94         /* Set up for threaded slapindex */
95         if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) {
96                 if ( !mdb_tool_info ) {
97                         ldap_pvt_thread_mutex_init( &mdb_tool_index_mutex );
98                         ldap_pvt_thread_cond_init( &mdb_tool_index_cond_main );
99                         ldap_pvt_thread_cond_init( &mdb_tool_index_cond_work );
100                         if ( mdb->bi_nattrs ) {
101                                 int i;
102                                 mdb_tool_index_threads = ch_malloc( slap_tool_thread_max * sizeof( int ));
103                                 mdb_tool_index_rec = ch_malloc( mdb->bi_nattrs * sizeof( IndexRec ));
104                                 mdb_tool_index_tcount = slap_tool_thread_max - 1;
105                                 for (i=1; i<slap_tool_thread_max; i++) {
106                                         int *ptr = ch_malloc( sizeof( int ));
107                                         *ptr = i;
108                                         ldap_pvt_thread_pool_submit( &connection_pool,
109                                                 mdb_tool_index_task, ptr );
110                                 }
111                         }
112                         mdb_tool_info = mdb;
113                 }
114         }
115 #endif
116
117         return 0;
118 }
119
120 int mdb_tool_entry_close(
121         BackendDB *be )
122 {
123 #if 0
124         if ( mdb_tool_info ) {
125                 slapd_shutdown = 1;
126                 ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
127
128                 /* There might still be some threads starting */
129                 while ( mdb_tool_index_tcount ) {
130                         ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
131                                         &mdb_tool_index_mutex );
132                 }
133
134                 mdb_tool_index_tcount = slap_tool_thread_max - 1;
135                 ldap_pvt_thread_cond_broadcast( &mdb_tool_index_cond_work );
136
137                 /* Make sure all threads are stopped */
138                 while ( mdb_tool_index_tcount ) {
139                         ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
140                                 &mdb_tool_index_mutex );
141                 }
142                 ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
143
144                 mdb_tool_info = NULL;
145                 slapd_shutdown = 0;
146                 ch_free( mdb_tool_index_threads );
147                 ch_free( mdb_tool_index_rec );
148                 mdb_tool_index_tcount = slap_tool_thread_max - 1;
149         }
150 #endif
151
152         if( idcursor ) {
153                 mdb_cursor_close( idcursor );
154                 idcursor = NULL;
155         }
156         if( cursor ) {
157                 mdb_cursor_close( cursor );
158                 cursor = NULL;
159         }
160         mdb_tool_idl_flush( be, txn );
161         if( txn ) {
162                 if ( mdb_txn_commit( txn ))
163                         return -1;
164                 txn = NULL;
165         }
166
167         if( nholes ) {
168                 unsigned i;
169                 fprintf( stderr, "Error, entries missing!\n");
170                 for (i=0; i<nholes; i++) {
171                         fprintf(stderr, "  entry %ld: %s\n",
172                                 holes[i].id, holes[i].dn.bv_val);
173                 }
174                 nholes = 0;
175                 return -1;
176         }
177
178         return 0;
179 }
180
181 ID
182 mdb_tool_entry_first_x(
183         BackendDB *be,
184         struct berval *base,
185         int scope,
186         Filter *f )
187 {
188         tool_base = base;
189         tool_scope = scope;
190         tool_filter = f;
191
192         return mdb_tool_entry_next( be );
193 }
194
195 ID mdb_tool_entry_next(
196         BackendDB *be )
197 {
198         int rc;
199         ID id;
200         struct mdb_info *mdb;
201
202         assert( be != NULL );
203         assert( slapMode & SLAP_TOOL_MODE );
204
205         mdb = (struct mdb_info *) be->be_private;
206         assert( mdb != NULL );
207
208         if ( !txn ) {
209                 rc = mdb_txn_begin( mdb->mi_dbenv, NULL, MDB_RDONLY, &txn );
210                 if ( rc )
211                         return NOID;
212                 rc = mdb_cursor_open( txn, mdb->mi_id2entry, &cursor );
213                 if ( rc ) {
214                         mdb_txn_abort( txn );
215                         return NOID;
216                 }
217         }
218
219 next:;
220         rc = mdb_cursor_get( cursor, &key, &data, MDB_NEXT );
221
222         if( rc ) {
223                 return NOID;
224         }
225
226         previd = *(ID *)key.mv_data;
227         id = previd;
228
229         if ( tool_filter || tool_base ) {
230                 static Operation op = {0};
231                 static Opheader ohdr = {0};
232
233                 op.o_hdr = &ohdr;
234                 op.o_bd = be;
235                 op.o_tmpmemctx = NULL;
236                 op.o_tmpmfuncs = &ch_mfuncs;
237
238                 if ( tool_next_entry ) {
239                         mdb_entry_release( &op, tool_next_entry, 0 );
240                         tool_next_entry = NULL;
241                 }
242
243                 rc = mdb_tool_entry_get_int( be, id, &tool_next_entry );
244                 if ( rc == LDAP_NO_SUCH_OBJECT ) {
245                         goto next;
246                 }
247
248                 assert( tool_next_entry != NULL );
249
250                 if ( tool_filter && test_filter( NULL, tool_next_entry, tool_filter ) != LDAP_COMPARE_TRUE )
251                 {
252                         mdb_entry_release( &op, tool_next_entry, 0 );
253                         tool_next_entry = NULL;
254                         goto next;
255                 }
256         }
257
258         return id;
259 }
260
261 ID mdb_tool_dn2id_get(
262         Backend *be,
263         struct berval *dn
264 )
265 {
266         struct mdb_info *mdb;
267         Operation op = {0};
268         Opheader ohdr = {0};
269         ID id;
270         int rc;
271
272         if ( BER_BVISEMPTY(dn) )
273                 return 0;
274
275         mdb = (struct mdb_info *) be->be_private;
276
277         if ( !txn ) {
278                 rc = mdb_txn_begin( mdb->mi_dbenv, NULL, (slapMode & SLAP_TOOL_READONLY) != 0 ?
279                         MDB_RDONLY : 0, &txn );
280                 if ( rc )
281                         return NOID;
282         }
283
284         op.o_hdr = &ohdr;
285         op.o_bd = be;
286         op.o_tmpmemctx = NULL;
287         op.o_tmpmfuncs = &ch_mfuncs;
288
289         rc = mdb_dn2id( &op, txn, dn, &id, NULL, NULL );
290         if ( rc == MDB_NOTFOUND )
291                 return NOID;
292
293         return id;
294 }
295
296 static int
297 mdb_tool_entry_get_int( BackendDB *be, ID id, Entry **ep )
298 {
299         Operation op = {0};
300         Opheader ohdr = {0};
301
302         Entry *e = NULL;
303         struct berval dn = BER_BVNULL, ndn = BER_BVNULL;
304         int rc;
305
306         assert( be != NULL );
307         assert( slapMode & SLAP_TOOL_MODE );
308
309         if ( ( tool_filter || tool_base ) && id == previd && tool_next_entry != NULL ) {
310                 *ep = tool_next_entry;
311                 tool_next_entry = NULL;
312                 return LDAP_SUCCESS;
313         }
314
315         if ( id != previd ) {
316                 key.mv_size = sizeof(ID);
317                 key.mv_data = &id;
318                 rc = mdb_cursor_get( cursor, &key, &data, MDB_SET );
319                 if ( rc ) {
320                         rc = LDAP_OTHER;
321                         goto done;
322                 }
323         }
324
325         op.o_hdr = &ohdr;
326         op.o_bd = be;
327         op.o_tmpmemctx = NULL;
328         op.o_tmpmfuncs = &ch_mfuncs;
329         if ( slapMode & SLAP_TOOL_READONLY ) {
330                 rc = mdb_id2name( &op, txn, &idcursor, id, &dn, &ndn );
331                 if ( rc  ) {
332                         rc = LDAP_OTHER;
333                         mdb_entry_return( &op, e );
334                         e = NULL;
335                         goto done;
336                 }
337                 if ( tool_base != NULL ) {
338                         if ( !dnIsSuffixScope( &ndn, tool_base, tool_scope ) ) {
339                                 ch_free( dn.bv_val );
340                                 ch_free( ndn.bv_val );
341                                 rc = LDAP_NO_SUCH_OBJECT;
342                         }
343                 }
344         }
345         rc = mdb_entry_decode( &op, &data, &e );
346         e->e_id = id;
347         if ( !BER_BVISNULL( &dn )) {
348                 e->e_name = dn;
349                 e->e_nname = ndn;
350         } else {
351                 e->e_name.bv_val = NULL;
352                 e->e_nname.bv_val = NULL;
353         }
354
355 done:
356         if ( e != NULL ) {
357                 *ep = e;
358         }
359
360         return rc;
361 }
362
363 Entry*
364 mdb_tool_entry_get( BackendDB *be, ID id )
365 {
366         Entry *e = NULL;
367
368         (void)mdb_tool_entry_get_int( be, id, &e );
369         return e;
370 }
371
372 static int mdb_tool_next_id(
373         Operation *op,
374         MDB_txn *tid,
375         Entry *e,
376         struct berval *text,
377         int hole )
378 {
379         struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
380         struct berval dn = e->e_name;
381         struct berval ndn = e->e_nname;
382         struct berval pdn, npdn, nmatched;
383         ID id, pid = 0;
384         int rc;
385
386         if (ndn.bv_len == 0) {
387                 e->e_id = 0;
388                 return 0;
389         }
390
391         rc = mdb_dn2id( op, tid, &ndn, &id, NULL, &nmatched );
392         if ( rc == MDB_NOTFOUND ) {
393                 if ( !be_issuffix( op->o_bd, &ndn ) ) {
394                         ID eid = e->e_id;
395                         dnParent( &ndn, &npdn );
396                         if ( nmatched.bv_len != npdn.bv_len ) {
397                                 dnParent( &dn, &pdn );
398                                 e->e_name = pdn;
399                                 e->e_nname = npdn;
400                                 rc = mdb_tool_next_id( op, tid, e, text, 1 );
401                                 e->e_name = dn;
402                                 e->e_nname = ndn;
403                                 if ( rc ) {
404                                         return rc;
405                                 }
406                                 /* If parent didn't exist, it was created just now
407                                  * and its ID is now in e->e_id. Make sure the current
408                                  * entry gets added under the new parent ID.
409                                  */
410                                 if ( eid != e->e_id ) {
411                                         pid = e->e_id;
412                                 }
413                         } else {
414                                 pid = id;
415                         }
416                 }
417                 rc = mdb_next_id( op->o_bd, tid, &e->e_id );
418                 if ( rc ) {
419                         snprintf( text->bv_val, text->bv_len,
420                                 "next_id failed: %s (%d)",
421                                 mdb_strerror(rc), rc );
422                 Debug( LDAP_DEBUG_ANY,
423                         "=> mdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
424                         return rc;
425                 }
426                 rc = mdb_dn2id_add( op, tid, pid, e );
427                 if ( rc ) {
428                         snprintf( text->bv_val, text->bv_len,
429                                 "dn2id_add failed: %s (%d)",
430                                 mdb_strerror(rc), rc );
431                         Debug( LDAP_DEBUG_ANY,
432                                 "=> mdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
433                 } else if ( hole ) {
434                         MDB_val key, data;
435                         if ( nholes == nhmax - 1 ) {
436                                 if ( holes == hbuf ) {
437                                         holes = ch_malloc( nhmax * sizeof(dn_id) * 2 );
438                                         AC_MEMCPY( holes, hbuf, sizeof(hbuf) );
439                                 } else {
440                                         holes = ch_realloc( holes, nhmax * sizeof(dn_id) * 2 );
441                                 }
442                                 nhmax *= 2;
443                         }
444                         ber_dupbv( &holes[nholes].dn, &ndn );
445                         holes[nholes++].id = e->e_id;
446                         key.mv_size = sizeof(ID);
447                         key.mv_data = &e->e_id;
448                         data.mv_size = 0;
449                         data.mv_data = NULL;
450                         rc = mdb_put( tid, mdb->mi_id2entry, &key, &data, MDB_NOOVERWRITE );
451                         if ( rc == MDB_KEYEXIST )
452                                 rc = 0;
453                         if ( rc ) {
454                                 snprintf( text->bv_val, text->bv_len,
455                                         "dummy id2entry add failed: %s (%d)",
456                                         mdb_strerror(rc), rc );
457                                 Debug( LDAP_DEBUG_ANY,
458                                         "=> mdb_tool_next_id: %s\n", text->bv_val, 0, 0 );
459                         }
460                 }
461         } else if ( !hole ) {
462                 unsigned i, j;
463
464                 e->e_id = id;
465
466                 for ( i=0; i<nholes; i++) {
467                         if ( holes[i].id == e->e_id ) {
468                                 free(holes[i].dn.bv_val);
469                                 for (j=i;j<nholes;j++) holes[j] = holes[j+1];
470                                 holes[j].id = 0;
471                                 nholes--;
472                                 break;
473                         } else if ( holes[i].id > e->e_id ) {
474                                 break;
475                         }
476                 }
477         }
478         return rc;
479 }
480
481 static int
482 mdb_tool_index_add(
483         Operation *op,
484         MDB_txn *txn,
485         Entry *e )
486 {
487         struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private;
488
489         if ( !mdb->mi_nattrs )
490                 return 0;
491
492 #if 0
493         if ( slapMode & SLAP_TOOL_QUICK ) {
494                 IndexRec *ir;
495                 int i, rc;
496                 Attribute *a;
497
498                 ir = mdb_tool_index_rec;
499                 memset(ir, 0, mdb->bi_nattrs * sizeof( IndexRec ));
500
501                 for ( a = e->e_attrs; a != NULL; a = a->a_next ) {
502                         rc = mdb_index_recset( mdb, a, a->a_desc->ad_type,
503                                 &a->a_desc->ad_tags, ir );
504                         if ( rc )
505                                 return rc;
506                 }
507                 mdb_tool_ix_id = e->e_id;
508                 mdb_tool_ix_op = op;
509                 ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
510                 /* Wait for all threads to be ready */
511                 while ( mdb_tool_index_tcount ) {
512                         ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
513                                 &mdb_tool_index_mutex );
514                 }
515                 for ( i=1; i<slap_tool_thread_max; i++ )
516                         mdb_tool_index_threads[i] = LDAP_BUSY;
517                 mdb_tool_index_tcount = slap_tool_thread_max - 1;
518                 ldap_pvt_thread_cond_broadcast( &mdb_tool_index_cond_work );
519                 ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
520                 rc = mdb_index_recrun( op, mdb, ir, e->e_id, 0 );
521                 if ( rc )
522                         return rc;
523                 ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
524                 for ( i=1; i<slap_tool_thread_max; i++ ) {
525                         if ( mdb_tool_index_threads[i] == LDAP_BUSY ) {
526                                 ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_main,
527                                         &mdb_tool_index_mutex );
528                                 i--;
529                                 continue;
530                         }
531                         if ( mdb_tool_index_threads[i] ) {
532                                 rc = mdb_tool_index_threads[i];
533                                 break;
534                         }
535                 }
536                 ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
537                 return rc;
538         } else
539 #endif
540         {
541                 return mdb_index_entry_add( op, txn, e );
542         }
543 }
544
545 ID mdb_tool_entry_put(
546         BackendDB *be,
547         Entry *e,
548         struct berval *text )
549 {
550         int rc;
551         struct mdb_info *mdb;
552         Operation op = {0};
553         Opheader ohdr = {0};
554
555         assert( be != NULL );
556         assert( slapMode & SLAP_TOOL_MODE );
557
558         assert( text != NULL );
559         assert( text->bv_val != NULL );
560         assert( text->bv_val[0] == '\0' );      /* overconservative? */
561
562         Debug( LDAP_DEBUG_TRACE, "=> " LDAP_XSTRING(mdb_tool_entry_put)
563                 "( %ld, \"%s\" )\n", (long) e->e_id, e->e_dn, 0 );
564
565         mdb = (struct mdb_info *) be->be_private;
566
567         if ( !txn ) {
568         rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &txn );
569         if( rc != 0 ) {
570                 snprintf( text->bv_val, text->bv_len,
571                         "txn_begin failed: %s (%d)",
572                         mdb_strerror(rc), rc );
573                 Debug( LDAP_DEBUG_ANY,
574                         "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
575                          text->bv_val, 0, 0 );
576                 return NOID;
577         }
578         }
579
580         op.o_hdr = &ohdr;
581         op.o_bd = be;
582         op.o_tmpmemctx = NULL;
583         op.o_tmpmfuncs = &ch_mfuncs;
584
585         /* add dn2id indices */
586         rc = mdb_tool_next_id( &op, txn, e, text, 0 );
587         if( rc != 0 ) {
588                 goto done;
589         }
590
591         rc = mdb_tool_index_add( &op, txn, e );
592         if( rc != 0 ) {
593                 snprintf( text->bv_val, text->bv_len,
594                                 "index_entry_add failed: err=%d", rc );
595                 Debug( LDAP_DEBUG_ANY,
596                         "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
597                         text->bv_val, 0, 0 );
598                 goto done;
599         }
600
601
602         /* id2entry index */
603         rc = mdb_id2entry_add( &op, txn, e );
604         if( rc != 0 ) {
605                 snprintf( text->bv_val, text->bv_len,
606                                 "id2entry_add failed: err=%d", rc );
607                 Debug( LDAP_DEBUG_ANY,
608                         "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
609                         text->bv_val, 0, 0 );
610                 goto done;
611         }
612
613 done:
614         if( rc == 0 ) {
615                 mdb_writes++;
616                 if ( mdb_writes >= mdb_writes_per_commit ) {
617                         mdb_tool_idl_flush( be, txn );
618                         rc = mdb_txn_commit( txn );
619                         mdb_writes = 0;
620                         txn = NULL;
621                         if( rc != 0 ) {
622                                 snprintf( text->bv_val, text->bv_len,
623                                                 "txn_commit failed: %s (%d)",
624                                                 mdb_strerror(rc), rc );
625                                 Debug( LDAP_DEBUG_ANY,
626                                         "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
627                                         text->bv_val, 0, 0 );
628                                 e->e_id = NOID;
629                         }
630                 }
631
632         } else {
633                 mdb_txn_abort( txn );
634                 txn = NULL;
635                 snprintf( text->bv_val, text->bv_len,
636                         "txn_aborted! %s (%d)",
637                         rc == LDAP_OTHER ? "Internal error" :
638                         mdb_strerror(rc), rc );
639                 Debug( LDAP_DEBUG_ANY,
640                         "=> " LDAP_XSTRING(mdb_tool_entry_put) ": %s\n",
641                         text->bv_val, 0, 0 );
642                 e->e_id = NOID;
643         }
644
645         return e->e_id;
646 }
647
648 int mdb_tool_entry_reindex(
649         BackendDB *be,
650         ID id,
651         AttributeDescription **adv )
652 {
653         struct mdb_info *mi = (struct mdb_info *) be->be_private;
654         int rc;
655         Entry *e;
656         Operation op = {0};
657         Opheader ohdr = {0};
658
659         Debug( LDAP_DEBUG_ARGS,
660                 "=> " LDAP_XSTRING(mdb_tool_entry_reindex) "( %ld )\n",
661                 (long) id, 0, 0 );
662         assert( tool_base == NULL );
663         assert( tool_filter == NULL );
664
665         /* No indexes configured, nothing to do. Could return an
666          * error here to shortcut things.
667          */
668         if (!mi->mi_attrs) {
669                 return 0;
670         }
671
672         /* Check for explicit list of attrs to index */
673         if ( adv ) {
674                 int i, j, n;
675
676                 if ( mi->mi_attrs[0]->ai_desc != adv[0] ) {
677                         /* count */
678                         for ( n = 0; adv[n]; n++ ) ;
679
680                         /* insertion sort */
681                         for ( i = 0; i < n; i++ ) {
682                                 AttributeDescription *ad = adv[i];
683                                 for ( j = i-1; j>=0; j--) {
684                                         if ( SLAP_PTRCMP( adv[j], ad ) <= 0 ) break;
685                                         adv[j+1] = adv[j];
686                                 }
687                                 adv[j+1] = ad;
688                         }
689                 }
690
691                 for ( i = 0; adv[i]; i++ ) {
692                         if ( mi->mi_attrs[i]->ai_desc != adv[i] ) {
693                                 for ( j = i+1; j < mi->mi_nattrs; j++ ) {
694                                         if ( mi->mi_attrs[j]->ai_desc == adv[i] ) {
695                                                 AttrInfo *ai = mi->mi_attrs[i];
696                                                 mi->mi_attrs[i] = mi->mi_attrs[j];
697                                                 mi->mi_attrs[j] = ai;
698                                                 break;
699                                         }
700                                 }
701                                 if ( j == mi->mi_nattrs ) {
702                                         Debug( LDAP_DEBUG_ANY,
703                                                 LDAP_XSTRING(mdb_tool_entry_reindex)
704                                                 ": no index configured for %s\n",
705                                                 adv[i]->ad_cname.bv_val, 0, 0 );
706                                         return -1;
707                                 }
708                         }
709                 }
710                 mi->mi_nattrs = i;
711         }
712
713         if ( slapMode & SLAP_TRUNCATE_MODE ) {
714                 int i;
715                 for ( i=0; i < mi->mi_nattrs; i++ ) {
716                         rc = mdb_drop( txn, mi->mi_attrs[i]->ai_dbi, 0 );
717                         if ( rc ) {
718                                 Debug( LDAP_DEBUG_ANY,
719                                         LDAP_XSTRING(mdb_tool_entry_reindex)
720                                         ": (Truncate) mdb_drop(%s) failed: %s (%d)\n",
721                                         mi->mi_attrs[i]->ai_desc->ad_type->sat_cname.bv_val,
722                                         mdb_strerror(rc), rc );
723                                 return -1;
724                         }
725                 }
726                 slapMode ^= SLAP_TRUNCATE_MODE;
727         }
728
729         e = mdb_tool_entry_get( be, id );
730
731         if( e == NULL ) {
732                 Debug( LDAP_DEBUG_ANY,
733                         LDAP_XSTRING(mdb_tool_entry_reindex)
734                         ": could not locate id=%ld\n",
735                         (long) id, 0, 0 );
736                 return -1;
737         }
738
739         if ( !txi ) {
740                 rc = mdb_txn_begin( mi->mi_dbenv, NULL, 0, &txi );
741                 if( rc != 0 ) {
742                         Debug( LDAP_DEBUG_ANY,
743                                 "=> " LDAP_XSTRING(mdb_tool_entry_reindex) ": "
744                                 "txn_begin failed: %s (%d)\n",
745                                 mdb_strerror(rc), rc, 0 );
746                         goto done;
747                 }
748         }
749
750         /*
751          * just (re)add them for now
752          * assume that some other routine (not yet implemented)
753          * will zap index databases
754          *
755          */
756
757         Debug( LDAP_DEBUG_TRACE,
758                 "=> " LDAP_XSTRING(mdb_tool_entry_reindex) "( %ld, \"%s\" )\n",
759                 (long) id, e->e_dn, 0 );
760
761         op.o_hdr = &ohdr;
762         op.o_bd = be;
763         op.o_tmpmemctx = NULL;
764         op.o_tmpmfuncs = &ch_mfuncs;
765
766         rc = mdb_tool_index_add( &op, txi, e );
767
768 done:
769         if( rc == 0 ) {
770                 mdb_writes++;
771                 if ( mdb_writes >= mdb_writes_per_commit ) {
772                         mdb_tool_idl_flush( be, txi );
773                         rc = mdb_txn_commit( txi );
774                         if( rc != 0 ) {
775                                 Debug( LDAP_DEBUG_ANY,
776                                         "=> " LDAP_XSTRING(mdb_tool_entry_reindex)
777                                         ": txn_commit failed: %s (%d)\n",
778                                         mdb_strerror(rc), rc, 0 );
779                                 e->e_id = NOID;
780                         }
781                         txi = NULL;
782                 }
783
784         } else {
785                 mdb_txn_abort( txi );
786                 Debug( LDAP_DEBUG_ANY,
787                         "=> " LDAP_XSTRING(mdb_tool_entry_reindex)
788                         ": txn_aborted! err=%d\n",
789                         rc, 0, 0 );
790                 e->e_id = NOID;
791                 txi = NULL;
792         }
793         mdb_entry_release( &op, e, 0 );
794
795         return rc;
796 }
797
798 ID mdb_tool_entry_modify(
799         BackendDB *be,
800         Entry *e,
801         struct berval *text )
802 {
803         int rc;
804         struct mdb_info *mdb;
805         MDB_txn *tid;
806         Operation op = {0};
807         Opheader ohdr = {0};
808
809         assert( be != NULL );
810         assert( slapMode & SLAP_TOOL_MODE );
811
812         assert( text != NULL );
813         assert( text->bv_val != NULL );
814         assert( text->bv_val[0] == '\0' );      /* overconservative? */
815
816         assert ( e->e_id != NOID );
817
818         Debug( LDAP_DEBUG_TRACE,
819                 "=> " LDAP_XSTRING(mdb_tool_entry_modify) "( %ld, \"%s\" )\n",
820                 (long) e->e_id, e->e_dn, 0 );
821
822         mdb = (struct mdb_info *) be->be_private;
823
824         if( cursor ) {
825                 mdb_cursor_close( cursor );
826                 cursor = NULL;
827         }
828         rc = mdb_txn_begin( mdb->mi_dbenv, NULL, 0, &tid );
829         if( rc != 0 ) {
830                 snprintf( text->bv_val, text->bv_len,
831                         "txn_begin failed: %s (%d)",
832                         mdb_strerror(rc), rc );
833                 Debug( LDAP_DEBUG_ANY,
834                         "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": %s\n",
835                          text->bv_val, 0, 0 );
836                 return NOID;
837         }
838
839         op.o_hdr = &ohdr;
840         op.o_bd = be;
841         op.o_tmpmemctx = NULL;
842         op.o_tmpmfuncs = &ch_mfuncs;
843
844         /* id2entry index */
845         rc = mdb_id2entry_update( &op, tid, e );
846         if( rc != 0 ) {
847                 snprintf( text->bv_val, text->bv_len,
848                                 "id2entry_update failed: err=%d", rc );
849                 Debug( LDAP_DEBUG_ANY,
850                         "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": %s\n",
851                         text->bv_val, 0, 0 );
852                 goto done;
853         }
854
855 done:
856         if( rc == 0 ) {
857                 rc = mdb_txn_commit( tid );
858                 if( rc != 0 ) {
859                         snprintf( text->bv_val, text->bv_len,
860                                         "txn_commit failed: %s (%d)",
861                                         mdb_strerror(rc), rc );
862                         Debug( LDAP_DEBUG_ANY,
863                                 "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": "
864                                 "%s\n", text->bv_val, 0, 0 );
865                         e->e_id = NOID;
866                 }
867
868         } else {
869                 mdb_txn_abort( tid );
870                 snprintf( text->bv_val, text->bv_len,
871                         "txn_aborted! %s (%d)",
872                         mdb_strerror(rc), rc );
873                 Debug( LDAP_DEBUG_ANY,
874                         "=> " LDAP_XSTRING(mdb_tool_entry_modify) ": %s\n",
875                         text->bv_val, 0, 0 );
876                 e->e_id = NOID;
877         }
878
879         return e->e_id;
880 }
881
882 #if 0
883 static void *
884 mdb_tool_index_task( void *ctx, void *ptr )
885 {
886         int base = *(int *)ptr;
887
888         free( ptr );
889         while ( 1 ) {
890                 ldap_pvt_thread_mutex_lock( &mdb_tool_index_mutex );
891                 mdb_tool_index_tcount--;
892                 if ( !mdb_tool_index_tcount )
893                         ldap_pvt_thread_cond_signal( &mdb_tool_index_cond_main );
894                 ldap_pvt_thread_cond_wait( &mdb_tool_index_cond_work,
895                         &mdb_tool_index_mutex );
896                 if ( slapd_shutdown ) {
897                         mdb_tool_index_tcount--;
898                         if ( !mdb_tool_index_tcount )
899                                 ldap_pvt_thread_cond_signal( &mdb_tool_index_cond_main );
900                         ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
901                         break;
902                 }
903                 ldap_pvt_thread_mutex_unlock( &mdb_tool_index_mutex );
904
905                 mdb_tool_index_threads[base] = mdb_index_recrun( mdb_tool_ix_op,
906                         mdb_tool_info, mdb_tool_index_rec, mdb_tool_ix_id, base );
907         }
908
909         return NULL;
910 }
911 #endif
912
913 static int
914 mdb_tool_idl_cmp( const void *v1, const void *v2 )
915 {
916         const mdb_tool_idl_cache *c1 = v1, *c2 = v2;
917         int rc;
918
919         if (( rc = c1->kstr.bv_len - c2->kstr.bv_len )) return rc;
920         return memcmp( c1->kstr.bv_val, c2->kstr.bv_val, c1->kstr.bv_len );
921 }
922
923 static int
924 mdb_tool_idl_flush_one( MDB_cursor *mc, mdb_tool_idl_cache *ic )
925 {
926         mdb_tool_idl_cache_entry *ice;
927         MDB_val key, data;
928         int i, rc;
929         ID id, nid;
930
931         /* Freshly allocated, ignore it */
932         if ( !ic->head && ic->count <= MDB_IDL_DB_SIZE ) {
933                 return 0;
934         }
935
936         key.mv_data = ic->kstr.bv_val;
937         key.mv_size = ic->kstr.bv_len;
938
939         rc = mdb_cursor_get( mc, &key, &data, MDB_SET );
940         /* If key already exists and we're writing a range... */
941         if ( rc == 0 && ic->count > MDB_IDL_DB_SIZE ) {
942                 nid = *(ID *)data.mv_data;
943                 /* If it's not currently a range, must delete old info */
944                 if ( nid ) {
945                         ic->first = nid;
946                         mdb_cursor_del( mc, MDB_NODUPDATA );
947
948                         goto setrange;
949                 } else {
950                         /* Skip lo */
951                         rc = mdb_cursor_get( mc, &key, &data, MDB_NEXT_DUP );
952
953                         /* Get hi */
954                         rc = mdb_cursor_get( mc, &key, &data, MDB_NEXT_DUP );
955
956                         /* Store range hi */
957                         data.mv_data = &ic->last;
958                         rc = mdb_cursor_put( mc, &key, &data, MDB_CURRENT );
959                 }
960                 rc = 0;
961         } else if ( rc && rc != MDB_NOTFOUND ) {
962                 rc = -1;
963         } else if ( ic->count > MDB_IDL_DB_SIZE ) {
964                 /* range, didn't exist before */
965 setrange:
966                 nid = 0;
967                 data.mv_size = sizeof(ID);
968                 data.mv_data = &nid;
969                 rc = mdb_cursor_put( mc, &key, &data, 0 );
970                 if ( rc == 0 ) {
971                         data.mv_data = &ic->first;
972                         rc = mdb_cursor_put( mc, &key, &data, 0 );
973                         if ( rc == 0 ) {
974                                 data.mv_data = &ic->last;
975                                 rc = mdb_cursor_put( mc, &key, &data, 0 );
976                         }
977                 }
978                 if ( rc ) {
979                         rc = -1;
980                 }
981         } else {
982                 int n;
983
984                 data.mv_size = sizeof(ID);
985                 /* Just a normal write */
986                 rc = 0;
987                 for ( ice = ic->head, n=0; ice; ice = ice->next, n++ ) {
988                         int end;
989                         if ( ice->next ) {
990                                 end = IDBLOCK;
991                         } else {
992                                 end = ic->count & (IDBLOCK-1);
993                                 if ( !end )
994                                         end = IDBLOCK;
995                         }
996                         for ( i=0; i<end; i++ ) {
997                                 if ( !ice->ids[i] ) continue;
998                                 data.mv_data = &ice->ids[i];
999                                 rc = mdb_cursor_put( mc, &key, &data, MDB_NODUPDATA|MDB_APPEND );
1000                                 if ( rc ) {
1001                                         if ( rc == MDB_KEYEXIST ) {
1002                                                 rc = 0;
1003                                                 continue;
1004                                         }
1005                                         rc = -1;
1006                                         break;
1007                                 }
1008                         }
1009                         if ( rc ) {
1010                                 rc = -1;
1011                                 break;
1012                         }
1013                 }
1014                 if ( ic->head ) {
1015                         ic->tail->next = mdb_tool_idl_free_list;
1016                         mdb_tool_idl_free_list = ic->head;
1017                 }
1018         }
1019         ch_free( ic );
1020         return rc;
1021 }
1022
1023 static int
1024 mdb_tool_idl_flush_db( MDB_txn *txn, MDB_dbi dbi, Avlnode *root )
1025 {
1026         MDB_cursor *mc;
1027         int rc;
1028
1029         mdb_cursor_open( txn, dbi, &mc );
1030         root = tavl_end( root, TAVL_DIR_LEFT );
1031         do {
1032                 rc = mdb_tool_idl_flush_one( mc, root->avl_data );
1033                 if ( rc != -1 )
1034                         rc = 0;
1035         } while ((root = tavl_next(root, TAVL_DIR_RIGHT)));
1036         mdb_cursor_close( mc );
1037
1038         return rc;
1039 }
1040
1041 static int
1042 mdb_tool_idl_flush( BackendDB *be, MDB_txn *txn )
1043 {
1044         struct mdb_info *mdb = (struct mdb_info *) be->be_private;
1045         int rc = 0;
1046         unsigned int i;
1047
1048         for ( i=MDB_NDB; i < mdb->mi_nattrs+MDB_NDB; i++ ) {
1049                 if ( !mdb_tool_roots[i] ) continue;
1050                 rc = mdb_tool_idl_flush_db( txn, i, mdb_tool_roots[i] );
1051                 tavl_free(mdb_tool_roots[i], NULL);
1052                 mdb_tool_roots[i] = NULL;
1053                 if ( rc )
1054                         break;
1055         }
1056         return rc;
1057 }
1058
1059 int mdb_tool_idl_add(
1060         MDB_cursor *mc,
1061         struct berval *keys,
1062         ID id )
1063 {
1064         MDB_dbi dbi;
1065         mdb_tool_idl_cache *ic, itmp;
1066         mdb_tool_idl_cache_entry *ice;
1067         int i, rc;
1068
1069         dbi = mdb_cursor_dbi(mc);
1070         for (i=0; keys[i].bv_val; i++) {
1071         itmp.kstr = keys[i];
1072         ic = tavl_find( (Avlnode *)mdb_tool_roots[dbi], &itmp, mdb_tool_idl_cmp );
1073
1074         /* No entry yet, create one */
1075         if ( !ic ) {
1076                 MDB_val key, data;
1077                 ID nid;
1078                 int rc;
1079
1080                 ic = ch_malloc( sizeof( mdb_tool_idl_cache ) + itmp.kstr.bv_len );
1081                 ic->kstr.bv_len = itmp.kstr.bv_len;
1082                 ic->kstr.bv_val = (char *)(ic+1);
1083                 memcpy( ic->kstr.bv_val, itmp.kstr.bv_val, ic->kstr.bv_len );
1084                 ic->head = ic->tail = NULL;
1085                 ic->last = 0;
1086                 ic->count = 0;
1087                 tavl_insert( (Avlnode **)&mdb_tool_roots[dbi], ic, mdb_tool_idl_cmp,
1088                         avl_dup_error );
1089
1090                 /* load existing key count here */
1091                 key.mv_size = keys[i].bv_len;
1092                 key.mv_data = keys[i].bv_val;
1093                 data.mv_size = sizeof( ID );
1094                 data.mv_data = &nid;
1095                 rc = mdb_cursor_get( mc, &key, &data, MDB_SET );
1096                 if ( rc == 0 ) {
1097                         if ( nid == 0 ) {
1098                                 ic->count = MDB_IDL_DB_SIZE+1;
1099                         } else {
1100                                 size_t count;
1101
1102                                 mdb_cursor_count( mc, &count );
1103                                 ic->count = count;
1104                                 ic->first = nid;
1105                         }
1106                 }
1107         }
1108         /* are we a range already? */
1109         if ( ic->count > MDB_IDL_DB_SIZE ) {
1110                 ic->last = id;
1111                 continue;
1112         /* Are we at the limit, and converting to a range? */
1113         } else if ( ic->count == MDB_IDL_DB_SIZE ) {
1114                 int n;
1115                 for ( ice = ic->head, n=0; ice; ice = ice->next, n++ )
1116                         /* counting */ ;
1117                 if ( n ) {
1118                         ic->tail->next = mdb_tool_idl_free_list;
1119                         mdb_tool_idl_free_list = ic->head;
1120                 }
1121                 ic->head = ic->tail = NULL;
1122                 ic->last = id;
1123                 ic->count++;
1124                 continue;
1125         }
1126         /* No free block, create that too */
1127         if ( !ic->tail || ( ic->count & (IDBLOCK-1)) == 0) {
1128                 ice = NULL;
1129                 if ( mdb_tool_idl_free_list ) {
1130                         ice = mdb_tool_idl_free_list;
1131                         mdb_tool_idl_free_list = ice->next;
1132                 }
1133                 if ( !ice ) {
1134                         ice = ch_malloc( sizeof( mdb_tool_idl_cache_entry ));
1135                 }
1136                 memset( ice, 0, sizeof( *ice ));
1137                 if ( !ic->head ) {
1138                         ic->head = ice;
1139                 } else {
1140                         ic->tail->next = ice;
1141                 }
1142                 ic->tail = ice;
1143                 if ( !ic->count )
1144                         ic->first = id;
1145         }
1146         ice = ic->tail;
1147         ice->ids[ ic->count & (IDBLOCK-1) ] = id;
1148         ic->count++;
1149         }
1150
1151         return 0;
1152 }