]> git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/dbcache.c
Merge remote-tracking branch 'origin/mdb.master'
[openldap] / servers / slapd / back-bdb / dbcache.c
1 /* dbcache.c - manage cache of open databases */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2000-2013 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
21 #include <ac/errno.h>
22 #include <ac/socket.h>
23 #include <ac/string.h>
24 #include <ac/time.h>
25 #include <sys/stat.h>
26
27 #include "slap.h"
28 #include "back-bdb.h"
29 #include "lutil_hash.h"
30
31 #ifdef BDB_INDEX_USE_HASH
32 /* Pass-thru hash function. Since the indexer is already giving us hash
33  * values as keys, we don't need BDB to re-hash them.
34  */
35 static u_int32_t
36 bdb_db_hash(
37         DB *db,
38         const void *bytes,
39         u_int32_t length
40 )
41 {
42         u_int32_t ret = 0;
43         unsigned char *dst = (unsigned char *)&ret;
44         const unsigned char *src = (const unsigned char *)bytes;
45
46         if ( length > sizeof(u_int32_t) )
47                 length = sizeof(u_int32_t);
48
49         while ( length ) {
50                 *dst++ = *src++;
51                 length--;
52         }
53         return ret;
54 }
55 #define BDB_INDEXTYPE   DB_HASH
56 #else
57 #define BDB_INDEXTYPE   DB_BTREE
58 #endif
59
60 /* If a configured size is found, return it, otherwise return 0 */
61 int
62 bdb_db_findsize(
63         struct bdb_info *bdb,
64         struct berval *name
65 )
66 {
67         struct bdb_db_pgsize *bp;
68         int rc;
69
70         for ( bp = bdb->bi_pagesizes; bp; bp=bp->bdp_next ) {
71                 rc = strncmp( name->bv_val, bp->bdp_name.bv_val, name->bv_len );
72                 if ( !rc ) {
73                         if ( name->bv_len == bp->bdp_name.bv_len )
74                                 return bp->bdp_size;
75                         if ( name->bv_len < bp->bdp_name.bv_len &&
76                                 bp->bdp_name.bv_val[name->bv_len] == '.' )
77                                 return bp->bdp_size;
78                 }
79         }
80         return 0;
81 }
82
83 int
84 bdb_db_cache(
85         Backend *be,
86         struct berval *name,
87         DB **dbout )
88 {
89         int i, flags;
90         int rc;
91         struct bdb_info *bdb = (struct bdb_info *) be->be_private;
92         struct bdb_db_info *db;
93         char *file;
94
95         *dbout = NULL;
96
97         for( i=BDB_NDB; i < bdb->bi_ndatabases; i++ ) {
98                 if( !ber_bvcmp( &bdb->bi_databases[i]->bdi_name, name) ) {
99                         *dbout = bdb->bi_databases[i]->bdi_db;
100                         return 0;
101                 }
102         }
103
104         ldap_pvt_thread_mutex_lock( &bdb->bi_database_mutex );
105
106         /* check again! may have been added by another thread */
107         for( i=BDB_NDB; i < bdb->bi_ndatabases; i++ ) {
108                 if( !ber_bvcmp( &bdb->bi_databases[i]->bdi_name, name) ) {
109                         *dbout = bdb->bi_databases[i]->bdi_db;
110                         ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
111                         return 0;
112                 }
113         }
114
115         if( i >= BDB_INDICES ) {
116                 ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
117                 return -1;
118         }
119
120         db = (struct bdb_db_info *) ch_calloc(1, sizeof(struct bdb_db_info));
121
122         ber_dupbv( &db->bdi_name, name );
123
124         rc = db_create( &db->bdi_db, bdb->bi_dbenv, 0 );
125         if( rc != 0 ) {
126                 Debug( LDAP_DEBUG_ANY,
127                         "bdb_db_cache: db_create(%s) failed: %s (%d)\n",
128                         bdb->bi_dbenv_home, db_strerror(rc), rc );
129                 ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
130                 ch_free( db );
131                 return rc;
132         }
133
134         if( !BER_BVISNULL( &bdb->bi_db_crypt_key )) {
135                 rc = db->bdi_db->set_flags( db->bdi_db, DB_ENCRYPT );
136                 if ( rc ) {
137                         Debug( LDAP_DEBUG_ANY,
138                                 "bdb_db_cache: db set_flags(DB_ENCRYPT)(%s) failed: %s (%d)\n",
139                                 bdb->bi_dbenv_home, db_strerror(rc), rc );
140                         ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
141                         db->bdi_db->close( db->bdi_db, 0 );
142                         ch_free( db );
143                         return rc;
144                 }
145         }
146
147         if( bdb->bi_flags & BDB_CHKSUM ) {
148                 rc = db->bdi_db->set_flags( db->bdi_db, DB_CHKSUM );
149                 if ( rc ) {
150                         Debug( LDAP_DEBUG_ANY,
151                                 "bdb_db_cache: db set_flags(DB_CHKSUM)(%s) failed: %s (%d)\n",
152                                 bdb->bi_dbenv_home, db_strerror(rc), rc );
153                         ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
154                         db->bdi_db->close( db->bdi_db, 0 );
155                         ch_free( db );
156                         return rc;
157                 }
158         }
159
160         /* If no explicit size set, use the FS default */
161         flags = bdb_db_findsize( bdb, name );
162         if ( flags )
163                 rc = db->bdi_db->set_pagesize( db->bdi_db, flags );
164
165 #ifdef BDB_INDEX_USE_HASH
166         rc = db->bdi_db->set_h_hash( db->bdi_db, bdb_db_hash );
167 #endif
168         rc = db->bdi_db->set_flags( db->bdi_db, DB_DUP | DB_DUPSORT );
169
170         file = ch_malloc( db->bdi_name.bv_len + sizeof(BDB_SUFFIX) );
171         strcpy( file, db->bdi_name.bv_val );
172         strcpy( file+db->bdi_name.bv_len, BDB_SUFFIX );
173
174 #ifdef HAVE_EBCDIC
175         __atoe( file );
176 #endif
177         flags = DB_CREATE | DB_THREAD;
178 #ifdef DB_AUTO_COMMIT
179         if ( !( slapMode & SLAP_TOOL_QUICK ))
180                 flags |= DB_AUTO_COMMIT;
181 #endif
182         /* Cannot Truncate when Transactions are in use */
183         if ( (slapMode & (SLAP_TOOL_QUICK|SLAP_TRUNCATE_MODE)) ==
184                 (SLAP_TOOL_QUICK|SLAP_TRUNCATE_MODE))
185                         flags |= DB_TRUNCATE;
186
187         rc = DB_OPEN( db->bdi_db,
188                 file, NULL /* name */,
189                 BDB_INDEXTYPE, bdb->bi_db_opflags | flags, bdb->bi_dbenv_mode );
190
191         ch_free( file );
192
193         if( rc != 0 ) {
194                 Debug( LDAP_DEBUG_ANY,
195                         "bdb_db_cache: db_open(%s) failed: %s (%d)\n",
196                         name->bv_val, db_strerror(rc), rc );
197                 ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
198                 return rc;
199         }
200
201         bdb->bi_databases[i] = db;
202         bdb->bi_ndatabases = i+1;
203
204         *dbout = db->bdi_db;
205
206         ldap_pvt_thread_mutex_unlock( &bdb->bi_database_mutex );
207         return 0;
208 }