]> git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/init.c
Merge remote-tracking branch 'origin/mdb.RE/0.9'
[openldap] / servers / slapd / back-bdb / init.c
1 /* init.c - initialize bdb backend */
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/unistd.h>
22 #include <ac/stdlib.h>
23 #include <ac/errno.h>
24 #include <sys/stat.h>
25 #include "back-bdb.h"
26 #include <lutil.h>
27 #include <ldap_rq.h>
28 #include "alock.h"
29 #include "config.h"
30
31 static const struct bdbi_database {
32         char *file;
33         struct berval name;
34         int type;
35         int flags;
36 } bdbi_databases[] = {
37         { "id2entry" BDB_SUFFIX, BER_BVC("id2entry"), DB_BTREE, 0 },
38         { "dn2id" BDB_SUFFIX, BER_BVC("dn2id"), DB_BTREE, 0 },
39         { NULL, BER_BVNULL, 0, 0 }
40 };
41
42 typedef void * db_malloc(size_t);
43 typedef void * db_realloc(void *, size_t);
44
45 #define bdb_db_init     BDB_SYMBOL(db_init)
46 #define bdb_db_open BDB_SYMBOL(db_open)
47 #define bdb_db_close BDB_SYMBOL(db_close)
48
49 static int
50 bdb_db_init( BackendDB *be, ConfigReply *cr )
51 {
52         struct bdb_info *bdb;
53         int rc;
54
55         Debug( LDAP_DEBUG_TRACE,
56                 LDAP_XSTRING(bdb_db_init) ": Initializing " BDB_UCTYPE " database\n",
57                 0, 0, 0 );
58
59         /* allocate backend-database-specific stuff */
60         bdb = (struct bdb_info *) ch_calloc( 1, sizeof(struct bdb_info) );
61
62         /* DBEnv parameters */
63         bdb->bi_dbenv_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
64         bdb->bi_dbenv_xflags = DB_TIME_NOTGRANTED;
65         bdb->bi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;
66
67         bdb->bi_cache.c_maxsize = DEFAULT_CACHE_SIZE;
68         bdb->bi_cache.c_minfree = 1;
69
70         bdb->bi_lock_detect = DB_LOCK_DEFAULT;
71         bdb->bi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
72         bdb->bi_search_stack = NULL;
73
74         ldap_pvt_thread_mutex_init( &bdb->bi_database_mutex );
75         ldap_pvt_thread_mutex_init( &bdb->bi_lastid_mutex );
76 #ifdef BDB_HIER
77         ldap_pvt_thread_mutex_init( &bdb->bi_modrdns_mutex );
78 #endif
79         ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_lru_mutex );
80         ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_count_mutex );
81         ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_eifree_mutex );
82         ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_dntree.bei_kids_mutex );
83         ldap_pvt_thread_rdwr_init ( &bdb->bi_cache.c_rwlock );
84         ldap_pvt_thread_rdwr_init( &bdb->bi_idl_tree_rwlock );
85         ldap_pvt_thread_mutex_init( &bdb->bi_idl_tree_lrulock );
86
87         be->be_private = bdb;
88         be->be_cf_ocs = be->bd_info->bi_cf_ocs;
89
90 #ifndef BDB_MULTIPLE_SUFFIXES
91         SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_ONE_SUFFIX;
92 #endif
93
94         rc = bdb_monitor_db_init( be );
95
96         return rc;
97 }
98
99 static int
100 bdb_db_close( BackendDB *be, ConfigReply *cr );
101
102 static int
103 bdb_db_open( BackendDB *be, ConfigReply *cr )
104 {
105         int rc, i;
106         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
107         struct stat stat1, stat2;
108         u_int32_t flags;
109         char path[MAXPATHLEN];
110         char *dbhome;
111         Entry *e = NULL;
112         int do_recover = 0, do_alock_recover = 0;
113         int alockt, quick = 0;
114         int do_retry = 1;
115
116         if ( be->be_suffix == NULL ) {
117                 Debug( LDAP_DEBUG_ANY,
118                         LDAP_XSTRING(bdb_db_open) ": need suffix.\n",
119                         1, 0, 0 );
120                 return -1;
121         }
122
123         Debug( LDAP_DEBUG_ARGS,
124                 LDAP_XSTRING(bdb_db_open) ": \"%s\"\n",
125                 be->be_suffix[0].bv_val, 0, 0 );
126
127         /* Check existence of dbenv_home. Any error means trouble */
128         rc = stat( bdb->bi_dbenv_home, &stat1 );
129         if( rc != 0 ) {
130                 Debug( LDAP_DEBUG_ANY,
131                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
132                         "cannot access database directory \"%s\" (%d).\n",
133                         be->be_suffix[0].bv_val, bdb->bi_dbenv_home, errno );
134                 return -1;
135         }
136
137         /* Perform database use arbitration/recovery logic */
138         alockt = (slapMode & SLAP_TOOL_READONLY) ? ALOCK_LOCKED : ALOCK_UNIQUE;
139         if ( slapMode & SLAP_TOOL_QUICK ) {
140                 alockt |= ALOCK_NOSAVE;
141                 quick = 1;
142         }
143
144         rc = alock_open( &bdb->bi_alock_info, 
145                                 "slapd", 
146                                 bdb->bi_dbenv_home, alockt );
147
148         /* alockt is TRUE if the existing environment was created in Quick mode */
149         alockt = (rc & ALOCK_NOSAVE) ? 1 : 0;
150         rc &= ~ALOCK_NOSAVE;
151
152         if( rc == ALOCK_RECOVER ) {
153                 Debug( LDAP_DEBUG_ANY,
154                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
155                         "unclean shutdown detected; attempting recovery.\n", 
156                         be->be_suffix[0].bv_val, 0, 0 );
157                 do_alock_recover = 1;
158                 do_recover = DB_RECOVER;
159         } else if( rc == ALOCK_BUSY ) {
160                 Debug( LDAP_DEBUG_ANY,
161                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
162                         "database already in use.\n", 
163                         be->be_suffix[0].bv_val, 0, 0 );
164                 return -1;
165         } else if( rc != ALOCK_CLEAN ) {
166                 Debug( LDAP_DEBUG_ANY,
167                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
168                         "alock package is unstable.\n", 
169                         be->be_suffix[0].bv_val, 0, 0 );
170                 return -1;
171         }
172         if ( rc == ALOCK_CLEAN )
173                 be->be_flags |= SLAP_DBFLAG_CLEAN;
174
175         /*
176          * The DB_CONFIG file may have changed. If so, recover the
177          * database so that new settings are put into effect. Also
178          * note the possible absence of DB_CONFIG in the log.
179          */
180         if( stat( bdb->bi_db_config_path, &stat1 ) == 0 ) {
181                 if ( !do_recover ) {
182                         char *ptr = lutil_strcopy(path, bdb->bi_dbenv_home);
183                         *ptr++ = LDAP_DIRSEP[0];
184                         strcpy( ptr, "__db.001" );
185                         if( stat( path, &stat2 ) == 0 ) {
186                                 if( stat2.st_mtime < stat1.st_mtime ) {
187                                         Debug( LDAP_DEBUG_ANY,
188                                                 LDAP_XSTRING(bdb_db_open) ": DB_CONFIG for suffix \"%s\" has changed.\n",
189                                                         be->be_suffix[0].bv_val, 0, 0 );
190                                         if ( quick ) {
191                                                 Debug( LDAP_DEBUG_ANY,
192                                                         "Cannot use Quick mode; perform manual recovery first.\n",
193                                                         0, 0, 0 );
194                                                 slapMode ^= SLAP_TOOL_QUICK;
195                                                 rc = -1;
196                                                 goto fail;
197                                         } else {
198                                                 Debug( LDAP_DEBUG_ANY,
199                                                         "Performing database recovery to activate new settings.\n",
200                                                         0, 0, 0 );
201                                         }
202                                         do_recover = DB_RECOVER;
203                                 }
204                         }
205                 }
206         }
207         else {
208                 Debug( LDAP_DEBUG_ANY,
209                         LDAP_XSTRING(bdb_db_open) ": warning - no DB_CONFIG file found "
210                         "in directory %s: (%d).\n"
211                         "Expect poor performance for suffix \"%s\".\n",
212                         bdb->bi_dbenv_home, errno, be->be_suffix[0].bv_val );
213         }
214
215         /* Always let slapcat run, regardless of environment state.
216          * This can be used to cause a cache flush after an unclean
217          * shutdown.
218          */
219         if ( do_recover && ( slapMode & SLAP_TOOL_READONLY )) {
220                 Debug( LDAP_DEBUG_ANY,
221                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
222                         "recovery skipped in read-only mode. "
223                         "Run manual recovery if errors are encountered.\n",
224                         be->be_suffix[0].bv_val, 0, 0 );
225                 do_recover = 0;
226                 do_alock_recover = 0;
227                 quick = alockt;
228         }
229
230         /* An existing environment in Quick mode has nothing to recover. */
231         if ( alockt && do_recover ) {
232                 Debug( LDAP_DEBUG_ANY,
233                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
234                         "cannot recover, database must be reinitialized.\n", 
235                         be->be_suffix[0].bv_val, 0, 0 );
236                 rc = -1;
237                 goto fail;
238         }
239
240         rc = db_env_create( &bdb->bi_dbenv, 0 );
241         if( rc != 0 ) {
242                 Debug( LDAP_DEBUG_ANY,
243                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
244                         "db_env_create failed: %s (%d).\n",
245                         be->be_suffix[0].bv_val, db_strerror(rc), rc );
246                 goto fail;
247         }
248
249 #ifdef HAVE_EBCDIC
250         strcpy( path, bdb->bi_dbenv_home );
251         __atoe( path );
252         dbhome = path;
253 #else
254         dbhome = bdb->bi_dbenv_home;
255 #endif
256
257         /* If existing environment is clean but doesn't support
258          * currently requested modes, remove it.
259          */
260         if ( !do_recover && ( alockt ^ quick )) {
261 shm_retry:
262                 rc = bdb->bi_dbenv->remove( bdb->bi_dbenv, dbhome, DB_FORCE );
263                 if ( rc ) {
264                         Debug( LDAP_DEBUG_ANY,
265                                 LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
266                                 "dbenv remove failed: %s (%d).\n",
267                                 be->be_suffix[0].bv_val, db_strerror(rc), rc );
268                         bdb->bi_dbenv = NULL;
269                         goto fail;
270                 }
271                 rc = db_env_create( &bdb->bi_dbenv, 0 );
272                 if( rc != 0 ) {
273                         Debug( LDAP_DEBUG_ANY,
274                                 LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
275                                 "db_env_create failed: %s (%d).\n",
276                                 be->be_suffix[0].bv_val, db_strerror(rc), rc );
277                         goto fail;
278                 }
279         }
280
281         bdb->bi_dbenv->set_errpfx( bdb->bi_dbenv, be->be_suffix[0].bv_val );
282         bdb->bi_dbenv->set_errcall( bdb->bi_dbenv, bdb_errcall );
283
284         bdb->bi_dbenv->set_lk_detect( bdb->bi_dbenv, bdb->bi_lock_detect );
285
286         if ( !BER_BVISNULL( &bdb->bi_db_crypt_key )) {
287                 rc = bdb->bi_dbenv->set_encrypt( bdb->bi_dbenv, bdb->bi_db_crypt_key.bv_val,
288                         DB_ENCRYPT_AES );
289                 if ( rc ) {
290                         Debug( LDAP_DEBUG_ANY,
291                                 LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
292                                 "dbenv set_encrypt failed: %s (%d).\n",
293                                 be->be_suffix[0].bv_val, db_strerror(rc), rc );
294                         goto fail;
295                 }
296         }
297
298         /* One long-lived TXN per thread, two TXNs per write op */
299         bdb->bi_dbenv->set_tx_max( bdb->bi_dbenv, connection_pool_max * 3 );
300
301         if( bdb->bi_dbenv_xflags != 0 ) {
302                 rc = bdb->bi_dbenv->set_flags( bdb->bi_dbenv,
303                         bdb->bi_dbenv_xflags, 1);
304                 if( rc != 0 ) {
305                         Debug( LDAP_DEBUG_ANY,
306                                 LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
307                                 "dbenv_set_flags failed: %s (%d).\n",
308                                 be->be_suffix[0].bv_val, db_strerror(rc), rc );
309                         goto fail;
310                 }
311         }
312
313 #define BDB_TXN_FLAGS   (DB_INIT_LOCK | DB_INIT_LOG | DB_INIT_TXN)
314
315         Debug( LDAP_DEBUG_TRACE,
316                 LDAP_XSTRING(bdb_db_open) ": database \"%s\": "
317                 "dbenv_open(%s).\n",
318                 be->be_suffix[0].bv_val, bdb->bi_dbenv_home, 0);
319
320         flags = DB_INIT_MPOOL | DB_CREATE | DB_THREAD;
321
322         if ( !quick )
323                 flags |= BDB_TXN_FLAGS;
324
325         /* If a key was set, use shared memory for the BDB environment */
326         if ( bdb->bi_shm_key ) {
327                 bdb->bi_dbenv->set_shm_key( bdb->bi_dbenv, bdb->bi_shm_key );
328                 flags |= DB_SYSTEM_MEM;
329         }
330         rc = (bdb->bi_dbenv->open)( bdb->bi_dbenv, dbhome,
331                         flags | do_recover, bdb->bi_dbenv_mode );
332
333         if ( rc ) {
334                 /* Regular open failed, probably a missing shm environment.
335                  * Start over, do a recovery.
336                  */
337                 if ( !do_recover && bdb->bi_shm_key && do_retry ) {
338                         bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
339                         rc = db_env_create( &bdb->bi_dbenv, 0 );
340                         if( rc == 0 ) {
341                                 Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_db_open)
342                                         ": database \"%s\": "
343                                         "shared memory env open failed, assuming stale env.\n",
344                                         be->be_suffix[0].bv_val, 0, 0 );
345                                 do_retry = 0;
346                                 goto shm_retry;
347                         }
348                 }
349                 Debug( LDAP_DEBUG_ANY,
350                         LDAP_XSTRING(bdb_db_open) ": database \"%s\" cannot be %s, err %d. "
351                         "Restore from backup!\n",
352                         be->be_suffix[0].bv_val, do_recover ? "recovered" : "opened", rc );
353                 goto fail;
354         }
355
356         if ( do_alock_recover && alock_recover (&bdb->bi_alock_info) != 0 ) {
357                 Debug( LDAP_DEBUG_ANY,
358                         LDAP_XSTRING(bdb_db_open) ": database \"%s\": alock_recover failed\n",
359                         be->be_suffix[0].bv_val, 0, 0 );
360                 rc = -1;
361                 goto fail;
362         }
363
364 #ifdef SLAP_ZONE_ALLOC
365         if ( bdb->bi_cache.c_maxsize ) {
366                 bdb->bi_cache.c_zctx = slap_zn_mem_create(
367                         SLAP_ZONE_INITSIZE, SLAP_ZONE_MAXSIZE,
368                         SLAP_ZONE_DELTA, SLAP_ZONE_SIZE);
369         }
370 #endif
371
372         /* dncache defaults to 0 == unlimited
373          * must be >= entrycache
374          */
375         if ( bdb->bi_cache.c_eimax && bdb->bi_cache.c_eimax < bdb->bi_cache.c_maxsize ) {
376                 bdb->bi_cache.c_eimax = bdb->bi_cache.c_maxsize;
377         }
378
379         if ( bdb->bi_idl_cache_max_size ) {
380                 bdb->bi_idl_tree = NULL;
381                 bdb->bi_idl_cache_size = 0;
382         }
383
384         flags = DB_THREAD | bdb->bi_db_opflags;
385
386 #ifdef DB_AUTO_COMMIT
387         if ( !quick )
388                 flags |= DB_AUTO_COMMIT;
389 #endif
390
391         bdb->bi_databases = (struct bdb_db_info **) ch_malloc(
392                 BDB_INDICES * sizeof(struct bdb_db_info *) );
393
394         /* open (and create) main database */
395         for( i = 0; bdbi_databases[i].name.bv_val; i++ ) {
396                 struct bdb_db_info *db;
397
398                 db = (struct bdb_db_info *) ch_calloc(1, sizeof(struct bdb_db_info));
399
400                 rc = db_create( &db->bdi_db, bdb->bi_dbenv, 0 );
401                 if( rc != 0 ) {
402                         snprintf(cr->msg, sizeof(cr->msg),
403                                 "database \"%s\": db_create(%s) failed: %s (%d).",
404                                 be->be_suffix[0].bv_val, 
405                                 bdb->bi_dbenv_home, db_strerror(rc), rc );
406                         Debug( LDAP_DEBUG_ANY,
407                                 LDAP_XSTRING(bdb_db_open) ": %s\n",
408                                 cr->msg, 0, 0 );
409                         ch_free( db );
410                         goto fail;
411                 }
412
413                 if( !BER_BVISNULL( &bdb->bi_db_crypt_key )) {
414                         rc = db->bdi_db->set_flags( db->bdi_db, DB_ENCRYPT );
415                         if ( rc ) {
416                                 snprintf(cr->msg, sizeof(cr->msg),
417                                         "database \"%s\": db set_flags(DB_ENCRYPT)(%s) failed: %s (%d).",
418                                         be->be_suffix[0].bv_val, 
419                                         bdb->bi_dbenv_home, db_strerror(rc), rc );
420                                 Debug( LDAP_DEBUG_ANY,
421                                         LDAP_XSTRING(bdb_db_open) ": %s\n",
422                                         cr->msg, 0, 0 );
423                                 db->bdi_db->close( db->bdi_db, 0 );
424                                 ch_free( db );
425                                 goto fail;
426                         }
427                 }
428
429                 if( bdb->bi_flags & BDB_CHKSUM ) {
430                         rc = db->bdi_db->set_flags( db->bdi_db, DB_CHKSUM );
431                         if ( rc ) {
432                                 snprintf(cr->msg, sizeof(cr->msg),
433                                         "database \"%s\": db set_flags(DB_CHKSUM)(%s) failed: %s (%d).",
434                                         be->be_suffix[0].bv_val, 
435                                         bdb->bi_dbenv_home, db_strerror(rc), rc );
436                                 Debug( LDAP_DEBUG_ANY,
437                                         LDAP_XSTRING(bdb_db_open) ": %s\n",
438                                         cr->msg, 0, 0 );
439                                 db->bdi_db->close( db->bdi_db, 0 );
440                                 ch_free( db );
441                                 goto fail;
442                         }
443                 }
444
445                 rc = bdb_db_findsize( bdb, (struct berval *)&bdbi_databases[i].name );
446
447                 if( i == BDB_ID2ENTRY ) {
448                         if ( !rc ) rc = BDB_ID2ENTRY_PAGESIZE;
449                         rc = db->bdi_db->set_pagesize( db->bdi_db, rc );
450
451                         if ( slapMode & SLAP_TOOL_MODE )
452                                 db->bdi_db->mpf->set_priority( db->bdi_db->mpf,
453                                         DB_PRIORITY_VERY_LOW );
454
455                         if ( slapMode & SLAP_TOOL_READMAIN ) {
456                                 flags |= DB_RDONLY;
457                         } else {
458                                 flags |= DB_CREATE;
459                         }
460                 } else {
461                         /* Use FS default size if not configured */
462                         if ( rc )
463                                 rc = db->bdi_db->set_pagesize( db->bdi_db, rc );
464
465                         rc = db->bdi_db->set_flags( db->bdi_db, 
466                                 DB_DUP | DB_DUPSORT );
467 #ifndef BDB_HIER
468                         if ( slapMode & SLAP_TOOL_READONLY ) {
469                                 flags |= DB_RDONLY;
470                         } else {
471                                 flags |= DB_CREATE;
472                         }
473 #else
474                         rc = db->bdi_db->set_dup_compare( db->bdi_db,
475                                 bdb_dup_compare );
476                         if ( slapMode & (SLAP_TOOL_READONLY|SLAP_TOOL_READMAIN) ) {
477                                 flags |= DB_RDONLY;
478                         } else {
479                                 flags |= DB_CREATE;
480                         }
481 #endif
482                 }
483
484 #ifdef HAVE_EBCDIC
485                 strcpy( path, bdbi_databases[i].file );
486                 __atoe( path );
487                 rc = DB_OPEN( db->bdi_db,
488                         path,
489                 /*      bdbi_databases[i].name, */ NULL,
490                         bdbi_databases[i].type,
491                         bdbi_databases[i].flags | flags,
492                         bdb->bi_dbenv_mode );
493 #else
494                 rc = DB_OPEN( db->bdi_db,
495                         bdbi_databases[i].file,
496                 /*      bdbi_databases[i].name, */ NULL,
497                         bdbi_databases[i].type,
498                         bdbi_databases[i].flags | flags,
499                         bdb->bi_dbenv_mode );
500 #endif
501
502                 if ( rc != 0 ) {
503                         snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": "
504                                 "db_open(%s/%s) failed: %s (%d).", 
505                                 be->be_suffix[0].bv_val, 
506                                 bdb->bi_dbenv_home, bdbi_databases[i].file,
507                                 db_strerror(rc), rc );
508                         Debug( LDAP_DEBUG_ANY,
509                                 LDAP_XSTRING(bdb_db_open) ": %s\n",
510                                 cr->msg, 0, 0 );
511                         db->bdi_db->close( db->bdi_db, 0 );
512                         ch_free( db );
513                         goto fail;
514                 }
515
516                 flags &= ~(DB_CREATE | DB_RDONLY);
517                 db->bdi_name = bdbi_databases[i].name;
518                 bdb->bi_databases[i] = db;
519         }
520
521         bdb->bi_databases[i] = NULL;
522         bdb->bi_ndatabases = i;
523
524         /* get nextid */
525         rc = bdb_last_id( be, NULL );
526         if( rc != 0 ) {
527                 snprintf( cr->msg, sizeof(cr->msg), "database \"%s\": "
528                         "last_id(%s) failed: %s (%d).",
529                         be->be_suffix[0].bv_val, bdb->bi_dbenv_home,
530                         db_strerror(rc), rc );
531                 Debug( LDAP_DEBUG_ANY,
532                         LDAP_XSTRING(bdb_db_open) ": %s\n",
533                         cr->msg, 0, 0 );
534                 goto fail;
535         }
536
537         if ( !quick ) {
538                 int txflag = DB_READ_COMMITTED;
539                 /* avoid deadlocks in server; tools should
540                  * wait since they have no deadlock retry mechanism.
541                  */
542                 if ( slapMode & SLAP_SERVER_MODE )
543                         txflag |= DB_TXN_NOWAIT;
544                 TXN_BEGIN(bdb->bi_dbenv, NULL, &bdb->bi_cache.c_txn, txflag);
545         }
546
547         entry_prealloc( bdb->bi_cache.c_maxsize );
548         attr_prealloc( bdb->bi_cache.c_maxsize * 20 );
549
550         /* setup for empty-DN contexts */
551         if ( BER_BVISEMPTY( &be->be_nsuffix[0] )) {
552                 rc = bdb_id2entry( be, NULL, 0, &e );
553         }
554         if ( !e ) {
555                 struct berval gluebv = BER_BVC("glue");
556                 Operation op = {0};
557                 Opheader ohdr = {0};
558                 e = entry_alloc();
559                 e->e_id = 0;
560                 ber_dupbv( &e->e_name, (struct berval *)&slap_empty_bv );
561                 ber_dupbv( &e->e_nname, (struct berval *)&slap_empty_bv );
562                 attr_merge_one( e, slap_schema.si_ad_objectClass,
563                         &gluebv, NULL );
564                 attr_merge_one( e, slap_schema.si_ad_structuralObjectClass,
565                         &gluebv, NULL );
566                 op.o_hdr = &ohdr;
567                 op.o_bd = be;
568                 op.ora_e = e;
569                 op.o_dn = be->be_rootdn;
570                 op.o_ndn = be->be_rootndn;
571                 slap_add_opattrs( &op, NULL, NULL, 0, 0 );
572         }
573         e->e_ocflags = SLAP_OC_GLUE|SLAP_OC__END;
574         e->e_private = &bdb->bi_cache.c_dntree;
575         bdb->bi_cache.c_dntree.bei_e = e;
576
577         /* monitor setup */
578         rc = bdb_monitor_db_open( be );
579         if ( rc != 0 ) {
580                 goto fail;
581         }
582
583         bdb->bi_flags |= BDB_IS_OPEN;
584
585         return 0;
586
587 fail:
588         bdb_db_close( be, NULL );
589         return rc;
590 }
591
592 static int
593 bdb_db_close( BackendDB *be, ConfigReply *cr )
594 {
595         int rc;
596         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
597         struct bdb_db_info *db;
598         bdb_idl_cache_entry_t *entry, *next_entry;
599
600         /* monitor handling */
601         (void)bdb_monitor_db_close( be );
602
603         {
604                 Entry *e = bdb->bi_cache.c_dntree.bei_e;
605                 if ( e ) {
606                         bdb->bi_cache.c_dntree.bei_e = NULL;
607                         e->e_private = NULL;
608                         bdb_entry_return( e );
609                 }
610         }
611
612         bdb->bi_flags &= ~BDB_IS_OPEN;
613
614         ber_bvarray_free( bdb->bi_db_config );
615         bdb->bi_db_config = NULL;
616
617         if( bdb->bi_dbenv ) {
618                 /* Free cache locker if we enabled locking.
619                  * TXNs must all be closed before DBs...
620                  */
621                 if ( !( slapMode & SLAP_TOOL_QUICK ) && bdb->bi_cache.c_txn ) {
622                         TXN_ABORT( bdb->bi_cache.c_txn );
623                         bdb->bi_cache.c_txn = NULL;
624                 }
625                 bdb_reader_flush( bdb->bi_dbenv );
626         }
627
628         while( bdb->bi_databases && bdb->bi_ndatabases-- ) {
629                 db = bdb->bi_databases[bdb->bi_ndatabases];
630                 rc = db->bdi_db->close( db->bdi_db, 0 );
631                 /* Lower numbered names are not strdup'd */
632                 if( bdb->bi_ndatabases >= BDB_NDB )
633                         free( db->bdi_name.bv_val );
634                 free( db );
635         }
636         free( bdb->bi_databases );
637         bdb->bi_databases = NULL;
638
639         bdb_cache_release_all (&bdb->bi_cache);
640
641         if ( bdb->bi_idl_cache_size ) {
642                 avl_free( bdb->bi_idl_tree, NULL );
643                 bdb->bi_idl_tree = NULL;
644                 entry = bdb->bi_idl_lru_head;
645                 do {
646                         next_entry = entry->idl_lru_next;
647                         if ( entry->idl )
648                                 free( entry->idl );
649                         free( entry->kstr.bv_val );
650                         free( entry );
651                         entry = next_entry;
652                 } while ( entry != bdb->bi_idl_lru_head );
653                 bdb->bi_idl_lru_head = bdb->bi_idl_lru_tail = NULL;
654         }
655
656         /* close db environment */
657         if( bdb->bi_dbenv ) {
658                 /* force a checkpoint, but not if we were ReadOnly,
659                  * and not in Quick mode since there are no transactions there.
660                  */
661                 if ( !( slapMode & ( SLAP_TOOL_QUICK|SLAP_TOOL_READONLY ))) {
662                         rc = TXN_CHECKPOINT( bdb->bi_dbenv, 0, 0, DB_FORCE );
663                         if( rc != 0 ) {
664                                 Debug( LDAP_DEBUG_ANY,
665                                         "bdb_db_close: database \"%s\": "
666                                         "txn_checkpoint failed: %s (%d).\n",
667                                         be->be_suffix[0].bv_val, db_strerror(rc), rc );
668                         }
669                 }
670
671                 rc = bdb->bi_dbenv->close( bdb->bi_dbenv, 0 );
672                 bdb->bi_dbenv = NULL;
673                 if( rc != 0 ) {
674                         Debug( LDAP_DEBUG_ANY,
675                                 "bdb_db_close: database \"%s\": "
676                                 "close failed: %s (%d)\n",
677                                 be->be_suffix[0].bv_val, db_strerror(rc), rc );
678                         return rc;
679                 }
680         }
681
682         rc = alock_close( &bdb->bi_alock_info, slapMode & SLAP_TOOL_QUICK );
683         if( rc != 0 ) {
684                 Debug( LDAP_DEBUG_ANY,
685                         "bdb_db_close: database \"%s\": alock_close failed\n",
686                         be->be_suffix[0].bv_val, 0, 0 );
687                 return -1;
688         }
689
690         return 0;
691 }
692
693 static int
694 bdb_db_destroy( BackendDB *be, ConfigReply *cr )
695 {
696         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
697
698         /* stop and remove checkpoint task */
699         if ( bdb->bi_txn_cp_task ) {
700                 struct re_s *re = bdb->bi_txn_cp_task;
701                 bdb->bi_txn_cp_task = NULL;
702                 ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
703                 if ( ldap_pvt_runqueue_isrunning( &slapd_rq, re ) )
704                         ldap_pvt_runqueue_stoptask( &slapd_rq, re );
705                 ldap_pvt_runqueue_remove( &slapd_rq, re );
706                 ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
707         }
708
709         /* monitor handling */
710         (void)bdb_monitor_db_destroy( be );
711
712         if( bdb->bi_dbenv_home ) ch_free( bdb->bi_dbenv_home );
713         if( bdb->bi_db_config_path ) ch_free( bdb->bi_db_config_path );
714
715         bdb_attr_index_destroy( bdb );
716
717         ldap_pvt_thread_rdwr_destroy ( &bdb->bi_cache.c_rwlock );
718         ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_lru_mutex );
719         ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_count_mutex );
720         ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_eifree_mutex );
721         ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_dntree.bei_kids_mutex );
722 #ifdef BDB_HIER
723         ldap_pvt_thread_mutex_destroy( &bdb->bi_modrdns_mutex );
724 #endif
725         ldap_pvt_thread_mutex_destroy( &bdb->bi_lastid_mutex );
726         ldap_pvt_thread_mutex_destroy( &bdb->bi_database_mutex );
727         ldap_pvt_thread_rdwr_destroy( &bdb->bi_idl_tree_rwlock );
728         ldap_pvt_thread_mutex_destroy( &bdb->bi_idl_tree_lrulock );
729
730         ch_free( bdb );
731         be->be_private = NULL;
732
733         return 0;
734 }
735
736 int
737 bdb_back_initialize(
738         BackendInfo     *bi )
739 {
740         int rc;
741
742         static char *controls[] = {
743                 LDAP_CONTROL_ASSERT,
744                 LDAP_CONTROL_MANAGEDSAIT,
745                 LDAP_CONTROL_NOOP,
746                 LDAP_CONTROL_PAGEDRESULTS,
747                 LDAP_CONTROL_PRE_READ,
748                 LDAP_CONTROL_POST_READ,
749                 LDAP_CONTROL_SUBENTRIES,
750                 LDAP_CONTROL_X_PERMISSIVE_MODIFY,
751 #ifdef LDAP_X_TXN
752                 LDAP_CONTROL_X_TXN_SPEC,
753 #endif
754                 NULL
755         };
756
757         /* initialize the underlying database system */
758         Debug( LDAP_DEBUG_TRACE,
759                 LDAP_XSTRING(bdb_back_initialize) ": initialize " 
760                 BDB_UCTYPE " backend\n", 0, 0, 0 );
761
762         bi->bi_flags |=
763                 SLAP_BFLAG_INCREMENT |
764                 SLAP_BFLAG_SUBENTRIES |
765                 SLAP_BFLAG_ALIASES |
766                 SLAP_BFLAG_REFERRALS;
767
768         bi->bi_controls = controls;
769
770         {       /* version check */
771                 int major, minor, patch, ver;
772                 char *version = db_version( &major, &minor, &patch );
773 #ifdef HAVE_EBCDIC
774                 char v2[1024];
775
776                 /* All our stdio does an ASCII to EBCDIC conversion on
777                  * the output. Strings from the BDB library are already
778                  * in EBCDIC; we have to go back and forth...
779                  */
780                 strcpy( v2, version );
781                 __etoa( v2 );
782                 version = v2;
783 #endif
784
785                 ver = (major << 24) | (minor << 16) | patch;
786                 if( ver != DB_VERSION_FULL ) {
787                         /* fail if a versions don't match */
788                         Debug( LDAP_DEBUG_ANY,
789                                 LDAP_XSTRING(bdb_back_initialize) ": "
790                                 "BDB library version mismatch:"
791                                 " expected " DB_VERSION_STRING ","
792                                 " got %s\n", version, 0, 0 );
793                         return -1;
794                 }
795
796                 Debug( LDAP_DEBUG_TRACE, LDAP_XSTRING(bdb_back_initialize)
797                         ": %s\n", version, 0, 0 );
798         }
799
800         db_env_set_func_free( ber_memfree );
801         db_env_set_func_malloc( (db_malloc *)ber_memalloc );
802         db_env_set_func_realloc( (db_realloc *)ber_memrealloc );
803 #if !defined(NO_THREAD) && DB_VERSION_FULL <= 0x04070000
804         /* This is a no-op on a NO_THREAD build. Leave the default
805          * alone so that BDB will sleep on interprocess conflicts.
806          * Don't bother on BDB 4.7...
807          */
808         db_env_set_func_yield( ldap_pvt_thread_yield );
809 #endif
810
811         bi->bi_open = 0;
812         bi->bi_close = 0;
813         bi->bi_config = 0;
814         bi->bi_destroy = 0;
815
816         bi->bi_db_init = bdb_db_init;
817         bi->bi_db_config = config_generic_wrapper;
818         bi->bi_db_open = bdb_db_open;
819         bi->bi_db_close = bdb_db_close;
820         bi->bi_db_destroy = bdb_db_destroy;
821
822         bi->bi_op_add = bdb_add;
823         bi->bi_op_bind = bdb_bind;
824         bi->bi_op_compare = bdb_compare;
825         bi->bi_op_delete = bdb_delete;
826         bi->bi_op_modify = bdb_modify;
827         bi->bi_op_modrdn = bdb_modrdn;
828         bi->bi_op_search = bdb_search;
829
830         bi->bi_op_unbind = 0;
831
832         bi->bi_extended = bdb_extended;
833
834         bi->bi_chk_referrals = bdb_referrals;
835         bi->bi_operational = bdb_operational;
836         bi->bi_has_subordinates = bdb_hasSubordinates;
837         bi->bi_entry_release_rw = bdb_entry_release;
838         bi->bi_entry_get_rw = bdb_entry_get;
839
840         /*
841          * hooks for slap tools
842          */
843         bi->bi_tool_entry_open = bdb_tool_entry_open;
844         bi->bi_tool_entry_close = bdb_tool_entry_close;
845         bi->bi_tool_entry_first = backend_tool_entry_first;
846         bi->bi_tool_entry_first_x = bdb_tool_entry_first_x;
847         bi->bi_tool_entry_next = bdb_tool_entry_next;
848         bi->bi_tool_entry_get = bdb_tool_entry_get;
849         bi->bi_tool_entry_put = bdb_tool_entry_put;
850         bi->bi_tool_entry_reindex = bdb_tool_entry_reindex;
851         bi->bi_tool_sync = 0;
852         bi->bi_tool_dn2id_get = bdb_tool_dn2id_get;
853         bi->bi_tool_entry_modify = bdb_tool_entry_modify;
854
855         bi->bi_connection_init = 0;
856         bi->bi_connection_destroy = 0;
857
858         rc = bdb_back_init_cf( bi );
859
860         return rc;
861 }
862
863 #if     (SLAPD_BDB == SLAPD_MOD_DYNAMIC && !defined(BDB_HIER)) || \
864         (SLAPD_HDB == SLAPD_MOD_DYNAMIC && defined(BDB_HIER))
865
866 /* conditionally define the init_module() function */
867 #ifdef BDB_HIER
868 SLAP_BACKEND_INIT_MODULE( hdb )
869 #else /* !BDB_HIER */
870 SLAP_BACKEND_INIT_MODULE( bdb )
871 #endif /* !BDB_HIER */
872
873 #endif /* SLAPD_[BH]DB == SLAPD_MOD_DYNAMIC */
874