2 Unix SMB/CIFS implementation.
4 trivial database library
6 Copyright (C) Andrew Tridgell 1999-2005
7 Copyright (C) Paul `Rusty' Russell 2000
8 Copyright (C) Jeremy Allison 2000-2003
10 ** NOTE! The following LGPL license applies to the tdb
11 ** library. This does NOT imply that all of Samba is released
14 This library is free software; you can redistribute it and/or
15 modify it under the terms of the GNU Lesser General Public
16 License as published by the Free Software Foundation; either
17 version 3 of the License, or (at your option) any later version.
19 This library is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 Lesser General Public License for more details.
24 You should have received a copy of the GNU Lesser General Public
25 License along with this library; if not, see <http://www.gnu.org/licenses/>.
29 #include "tdb1_private.h"
31 #define MAX(a,b) ((a) > (b) ? (a) : (b))
34 /* check for an out of bounds access - if it is out of bounds then
35 see if the database has been expanded by someone else and expand
37 note that "len" is the minimum length needed for the db
39 static int tdb1_oob(struct tdb1_context
*tdb
, tdb1_off_t len
, int probe
)
42 if (len
<= tdb
->map_size
)
44 if (tdb
->flags
& TDB1_INTERNAL
) {
46 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
47 "tdb1_oob len %d beyond internal malloc size %d",
48 (int)len
, (int)tdb
->map_size
);
53 if (fstat(tdb
->fd
, &st
) == -1) {
54 tdb
->last_error
= TDB_ERR_IO
;
58 if (st
.st_size
< (size_t)len
) {
60 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
61 "tdb1_oob len %d beyond eof at %d",
62 (int)len
, (int)st
.st_size
);
67 /* Unmap, update size, remap */
68 if (tdb1_munmap(tdb
) == -1) {
69 tdb
->last_error
= TDB_ERR_IO
;
72 tdb
->map_size
= st
.st_size
;
77 /* write a lump of data at a specified offset */
78 static int tdb1_write(struct tdb1_context
*tdb
, tdb1_off_t off
,
79 const void *buf
, tdb1_len_t len
)
85 if (tdb
->read_only
|| tdb
->traverse_read
) {
86 tdb
->last_error
= TDB_ERR_RDONLY
;
90 if (tdb
->methods
->tdb1_oob(tdb
, off
+ len
, 0) != 0)
94 memcpy(off
+ (char *)tdb
->map_ptr
, buf
, len
);
96 ssize_t written
= pwrite(tdb
->fd
, buf
, len
, off
);
97 if ((written
!= (ssize_t
)len
) && (written
!= -1)) {
98 tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_WARNING
,
99 "tdb1_write: wrote only "
100 "%d of %d bytes at %d, trying once more",
101 (int)written
, len
, off
);
102 written
= pwrite(tdb
->fd
, (const char *)buf
+written
,
107 /* Ensure ecode is set for log fn. */
108 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
109 "tdb1_write failed at %d "
111 off
, len
, strerror(errno
));
113 } else if (written
!= (ssize_t
)len
) {
114 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
115 "tdb1_write: failed to "
116 "write %d bytes at %d in two attempts",
124 /* Endian conversion: we only ever deal with 4 byte quantities */
125 void *tdb1_convert(void *buf
, uint32_t size
)
127 uint32_t i
, *p
= (uint32_t *)buf
;
128 for (i
= 0; i
< size
/ 4; i
++)
129 p
[i
] = TDB1_BYTEREV(p
[i
]);
134 /* read a lump of data at a specified offset, maybe convert */
135 static int tdb1_read(struct tdb1_context
*tdb
, tdb1_off_t off
, void *buf
,
136 tdb1_len_t len
, int cv
)
138 if (tdb
->methods
->tdb1_oob(tdb
, off
+ len
, 0) != 0) {
143 memcpy(buf
, off
+ (char *)tdb
->map_ptr
, len
);
145 ssize_t ret
= pread(tdb
->fd
, buf
, len
, off
);
146 if (ret
!= (ssize_t
)len
) {
147 /* Ensure ecode is set for log fn. */
148 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
149 "tdb1_read failed at %d "
150 "len=%d ret=%d (%s) map_size=%d",
151 (int)off
, (int)len
, (int)ret
,
158 tdb1_convert(buf
, len
);
166 do an unlocked scan of the hash table heads to find the next non-zero head. The value
167 will then be confirmed with the lock held
169 static void tdb1_next_hash_chain(struct tdb1_context
*tdb
, uint32_t *chain
)
173 for (;h
< tdb
->header
.hash_size
;h
++) {
174 if (0 != *(uint32_t *)(TDB1_HASH_TOP(h
) + (unsigned char *)tdb
->map_ptr
)) {
180 for (;h
< tdb
->header
.hash_size
;h
++) {
181 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(h
), &off
) != 0 || off
!= 0) {
190 int tdb1_munmap(struct tdb1_context
*tdb
)
192 if (tdb
->flags
& TDB1_INTERNAL
)
199 ret
= munmap(tdb
->map_ptr
, tdb
->map_size
);
208 void tdb1_mmap(struct tdb1_context
*tdb
)
210 if (tdb
->flags
& TDB1_INTERNAL
)
214 if (!(tdb
->flags
& TDB1_NOMMAP
)) {
215 tdb
->map_ptr
= mmap(NULL
, tdb
->map_size
,
216 PROT_READ
|(tdb
->read_only
? 0:PROT_WRITE
),
217 MAP_SHARED
|MAP_FILE
, tdb
->fd
, 0);
220 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
223 if (tdb
->map_ptr
== MAP_FAILED
) {
225 tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_WARNING
,
226 "tdb1_mmap failed for size %d (%s)",
227 tdb
->map_size
, strerror(errno
));
237 /* expand a file. we prefer to use ftruncate, as that is what posix
238 says to use for mmap expansion */
239 static int tdb1_expand_file(struct tdb1_context
*tdb
, tdb1_off_t size
, tdb1_off_t addition
)
243 if (tdb
->read_only
|| tdb
->traverse_read
) {
244 tdb
->last_error
= TDB_ERR_RDONLY
;
248 if (ftruncate(tdb
->fd
, size
+addition
) == -1) {
250 ssize_t written
= pwrite(tdb
->fd
, &b
, 1, (size
+addition
) - 1);
252 /* try once more, potentially revealing errno */
253 written
= pwrite(tdb
->fd
, &b
, 1, (size
+addition
) - 1);
256 /* again - give up, guessing errno */
260 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
261 "expand_file to %d failed (%s)",
268 /* now fill the file with something. This ensures that the
269 file isn't sparse, which would be very bad if we ran out of
270 disk. This must be done with write, not via mmap */
271 memset(buf
, TDB1_PAD_BYTE
, sizeof(buf
));
273 size_t n
= addition
>sizeof(buf
)?sizeof(buf
):addition
;
274 ssize_t written
= pwrite(tdb
->fd
, buf
, n
, size
);
276 /* prevent infinite loops: try _once_ more */
277 written
= pwrite(tdb
->fd
, buf
, n
, size
);
280 /* give up, trying to provide a useful errno */
281 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
283 "returned 0 twice: giving up!");
286 } else if (written
== -1) {
287 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_ERROR
,
288 "expand_file write of "
289 "%d bytes failed (%s)", (int)n
,
292 } else if (written
!= n
) {
293 tdb_logerr(tdb
, TDB_ERR_IO
, TDB_LOG_WARNING
,
294 "expand_file: wrote "
295 "only %d of %d bytes - retrying",
296 (int)written
, (int)n
);
305 /* expand the database at least size bytes by expanding the underlying
306 file and doing the mmap again if necessary */
307 int tdb1_expand(struct tdb1_context
*tdb
, tdb1_off_t size
)
309 struct tdb1_record rec
;
310 tdb1_off_t offset
, new_size
, top_size
, map_size
;
312 if (tdb1_lock(tdb
, -1, F_WRLCK
) == -1) {
313 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
314 "lock failed in tdb1_expand");
318 /* must know about any previous expansions by another process */
319 tdb
->methods
->tdb1_oob(tdb
, tdb
->map_size
+ 1, 1);
321 /* limit size in order to avoid using up huge amounts of memory for
322 * in memory tdbs if an oddball huge record creeps in */
323 if (size
> 100 * 1024) {
324 top_size
= tdb
->map_size
+ size
* 2;
326 top_size
= tdb
->map_size
+ size
* 100;
329 /* always make room for at least top_size more records, and at
330 least 25% more space. if the DB is smaller than 100MiB,
331 otherwise grow it by 10% only. */
332 if (tdb
->map_size
> 100 * 1024 * 1024) {
333 map_size
= tdb
->map_size
* 1.10;
335 map_size
= tdb
->map_size
* 1.25;
338 /* Round the database up to a multiple of the page size */
339 new_size
= MAX(top_size
, map_size
);
340 size
= TDB1_ALIGN(new_size
, tdb
->page_size
) - tdb
->map_size
;
342 if (!(tdb
->flags
& TDB1_INTERNAL
))
346 * We must ensure the file is unmapped before doing this
347 * to ensure consistency with systems like OpenBSD where
348 * writes and mmaps are not consistent.
351 /* expand the file itself */
352 if (!(tdb
->flags
& TDB1_INTERNAL
)) {
353 if (tdb
->methods
->tdb1_expand_file(tdb
, tdb
->map_size
, size
) != 0)
357 tdb
->map_size
+= size
;
359 if (tdb
->flags
& TDB1_INTERNAL
) {
360 char *new_map_ptr
= (char *)realloc(tdb
->map_ptr
,
363 tdb
->map_size
-= size
;
366 tdb
->map_ptr
= new_map_ptr
;
369 * We must ensure the file is remapped before adding the space
370 * to ensure consistency with systems like OpenBSD where
371 * writes and mmaps are not consistent.
374 /* We're ok if the mmap fails as we'll fallback to read/write */
378 /* form a new freelist record */
379 memset(&rec
,'\0',sizeof(rec
));
380 rec
.rec_len
= size
- sizeof(rec
);
382 /* link it into the free list */
383 offset
= tdb
->map_size
- size
;
384 if (tdb1_free(tdb
, offset
, &rec
) == -1)
387 tdb1_unlock(tdb
, -1, F_WRLCK
);
390 tdb1_unlock(tdb
, -1, F_WRLCK
);
394 /* read/write a tdb1_off_t */
395 int tdb1_ofs_read(struct tdb1_context
*tdb
, tdb1_off_t offset
, tdb1_off_t
*d
)
397 return tdb
->methods
->tdb1_read(tdb
, offset
, (char*)d
, sizeof(*d
), TDB1_DOCONV());
400 int tdb1_ofs_write(struct tdb1_context
*tdb
, tdb1_off_t offset
, tdb1_off_t
*d
)
403 return tdb
->methods
->tdb1_write(tdb
, offset
, TDB1_CONV(off
), sizeof(*d
));
407 /* read a lump of data, allocating the space for it */
408 unsigned char *tdb1_alloc_read(struct tdb1_context
*tdb
, tdb1_off_t offset
, tdb1_len_t len
)
412 /* some systems don't like zero length malloc */
414 if (!(buf
= (unsigned char *)malloc(len
? len
: 1))) {
415 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_OOM
, TDB_LOG_ERROR
,
416 "tdb1_alloc_read malloc failed"
418 len
, strerror(errno
));
421 if (tdb
->methods
->tdb1_read(tdb
, offset
, buf
, len
, 0) == -1) {
428 /* Give a piece of tdb data to a parser */
430 int tdb1_parse_data(struct tdb1_context
*tdb
, TDB1_DATA key
,
431 tdb1_off_t offset
, tdb1_len_t len
,
432 int (*parser
)(TDB1_DATA key
, TDB1_DATA data
,
441 if ((tdb
->transaction
== NULL
) && (tdb
->map_ptr
!= NULL
)) {
443 * Optimize by avoiding the malloc/memcpy/free, point the
444 * parser directly at the mmap area.
446 if (tdb
->methods
->tdb1_oob(tdb
, offset
+len
, 0) != 0) {
449 data
.dptr
= offset
+ (unsigned char *)tdb
->map_ptr
;
450 return parser(key
, data
, private_data
);
453 if (!(data
.dptr
= tdb1_alloc_read(tdb
, offset
, len
))) {
457 result
= parser(key
, data
, private_data
);
462 /* read/write a record */
463 int tdb1_rec_read(struct tdb1_context
*tdb
, tdb1_off_t offset
, struct tdb1_record
*rec
)
465 if (tdb
->methods
->tdb1_read(tdb
, offset
, rec
, sizeof(*rec
),TDB1_DOCONV()) == -1)
467 if (TDB1_BAD_MAGIC(rec
)) {
468 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_CORRUPT
, TDB_LOG_ERROR
,
469 "tdb1_rec_read bad magic 0x%x at offset=%d",
473 return tdb
->methods
->tdb1_oob(tdb
, rec
->next
+sizeof(*rec
), 0);
476 int tdb1_rec_write(struct tdb1_context
*tdb
, tdb1_off_t offset
, struct tdb1_record
*rec
)
478 struct tdb1_record r
= *rec
;
479 return tdb
->methods
->tdb1_write(tdb
, offset
, TDB1_CONV(r
), sizeof(r
));
482 static const struct tdb1_methods io1_methods
= {
485 tdb1_next_hash_chain
,
491 initialise the default methods table
493 void tdb1_io_init(struct tdb1_context
*tdb
)
495 tdb
->methods
= &io1_methods
;