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/>.
28 #include "tdb_private.h"
30 _PUBLIC_ TDB_DATA tdb_null
;
33 non-blocking increment of the tdb sequence number if the tdb has been opened using
36 _PUBLIC_
void tdb_increment_seqnum_nonblock(struct tdb_context
*tdb
)
40 if (!(tdb
->flags
& TDB_SEQNUM
)) {
44 /* we ignore errors from this, as we have no sane way of
47 tdb_ofs_read(tdb
, TDB_SEQNUM_OFS
, &seqnum
);
49 tdb_ofs_write(tdb
, TDB_SEQNUM_OFS
, &seqnum
);
53 increment the tdb sequence number if the tdb has been opened using
56 static void tdb_increment_seqnum(struct tdb_context
*tdb
)
58 if (!(tdb
->flags
& TDB_SEQNUM
)) {
62 if (tdb_nest_lock(tdb
, TDB_SEQNUM_OFS
, F_WRLCK
,
63 TDB_LOCK_WAIT
|TDB_LOCK_PROBE
) != 0) {
67 tdb_increment_seqnum_nonblock(tdb
);
69 tdb_nest_unlock(tdb
, TDB_SEQNUM_OFS
, F_WRLCK
, false);
72 static int tdb_key_compare(TDB_DATA key
, TDB_DATA data
, void *private_data
)
74 return memcmp(data
.dptr
, key
.dptr
, data
.dsize
);
77 /* Returns 0 on fail. On success, return offset of record, and fills
79 static tdb_off_t
tdb_find(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
,
84 /* read in the hash top */
85 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(hash
), &rec_ptr
) == -1)
88 /* keep looking until we find the right record */
90 if (tdb_rec_read(tdb
, rec_ptr
, r
) == -1)
93 if (!TDB_DEAD(r
) && hash
==r
->full_hash
94 && key
.dsize
==r
->key_len
95 && tdb_parse_data(tdb
, key
, rec_ptr
+ sizeof(*r
),
96 r
->key_len
, tdb_key_compare
,
100 /* detect tight infinite loop */
101 if (rec_ptr
== r
->next
) {
102 tdb
->ecode
= TDB_ERR_CORRUPT
;
103 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_find: loop detected.\n"));
108 tdb
->ecode
= TDB_ERR_NOEXIST
;
112 /* As tdb_find, but if you succeed, keep the lock */
113 tdb_off_t
tdb_find_lock_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
, int locktype
,
114 struct tdb_record
*rec
)
118 if (tdb_lock(tdb
, BUCKET(hash
), locktype
) == -1)
120 if (!(rec_ptr
= tdb_find(tdb
, key
, hash
, rec
)))
121 tdb_unlock(tdb
, BUCKET(hash
), locktype
);
125 static TDB_DATA
_tdb_fetch(struct tdb_context
*tdb
, TDB_DATA key
);
127 static int tdb_update_hash_cmp(TDB_DATA key
, TDB_DATA data
, void *private_data
)
129 TDB_DATA
*dbuf
= (TDB_DATA
*)private_data
;
131 if (dbuf
->dsize
!= data
.dsize
) {
134 if (memcmp(dbuf
->dptr
, data
.dptr
, data
.dsize
) != 0) {
140 /* update an entry in place - this only works if the new data size
141 is <= the old data size and the key exists.
142 on failure return -1.
144 static int tdb_update_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
, TDB_DATA dbuf
)
146 struct tdb_record rec
;
150 if (!(rec_ptr
= tdb_find(tdb
, key
, hash
, &rec
)))
153 /* it could be an exact duplicate of what is there - this is
154 * surprisingly common (eg. with a ldb re-index). */
155 if (rec
.key_len
== key
.dsize
&&
156 rec
.data_len
== dbuf
.dsize
&&
157 rec
.full_hash
== hash
&&
158 tdb_parse_record(tdb
, key
, tdb_update_hash_cmp
, &dbuf
) == 0) {
162 /* must be long enough key, data and tailer */
163 if (rec
.rec_len
< key
.dsize
+ dbuf
.dsize
+ sizeof(tdb_off_t
)) {
164 tdb
->ecode
= TDB_SUCCESS
; /* Not really an error */
168 if (tdb
->methods
->tdb_write(tdb
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
169 dbuf
.dptr
, dbuf
.dsize
) == -1)
172 if (dbuf
.dsize
!= rec
.data_len
) {
174 rec
.data_len
= dbuf
.dsize
;
175 return tdb_rec_write(tdb
, rec_ptr
, &rec
);
181 /* find an entry in the database given a key */
182 /* If an entry doesn't exist tdb_err will be set to
183 * TDB_ERR_NOEXIST. If a key has no data attached
184 * then the TDB_DATA will have zero length but
187 static TDB_DATA
_tdb_fetch(struct tdb_context
*tdb
, TDB_DATA key
)
190 struct tdb_record rec
;
194 /* find which hash bucket it is in */
195 hash
= tdb
->hash_fn(&key
);
196 if (!(rec_ptr
= tdb_find_lock_hash(tdb
,key
,hash
,F_RDLCK
,&rec
)))
199 ret
.dptr
= tdb_alloc_read(tdb
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
201 ret
.dsize
= rec
.data_len
;
202 tdb_unlock(tdb
, BUCKET(rec
.full_hash
), F_RDLCK
);
206 _PUBLIC_ TDB_DATA
tdb_fetch(struct tdb_context
*tdb
, TDB_DATA key
)
208 TDB_DATA ret
= _tdb_fetch(tdb
, key
);
210 tdb_trace_1rec_retrec(tdb
, "tdb_fetch", key
, ret
);
215 * Find an entry in the database and hand the record's data to a parsing
216 * function. The parsing function is executed under the chain read lock, so it
217 * should be fast and should not block on other syscalls.
219 * DON'T CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
221 * For mmapped tdb's that do not have a transaction open it points the parsing
222 * function directly at the mmap area, it avoids the malloc/memcpy in this
223 * case. If a transaction is open or no mmap is available, it has to do
224 * malloc/read/parse/free.
226 * This is interesting for all readers of potentially large data structures in
227 * the tdb records, ldb indexes being one example.
229 * Return -1 if the record was not found.
232 _PUBLIC_
int tdb_parse_record(struct tdb_context
*tdb
, TDB_DATA key
,
233 int (*parser
)(TDB_DATA key
, TDB_DATA data
,
238 struct tdb_record rec
;
242 /* find which hash bucket it is in */
243 hash
= tdb
->hash_fn(&key
);
245 if (!(rec_ptr
= tdb_find_lock_hash(tdb
,key
,hash
,F_RDLCK
,&rec
))) {
246 /* record not found */
247 tdb_trace_1rec_ret(tdb
, "tdb_parse_record", key
, -1);
248 tdb
->ecode
= TDB_ERR_NOEXIST
;
251 tdb_trace_1rec_ret(tdb
, "tdb_parse_record", key
, 0);
253 ret
= tdb_parse_data(tdb
, key
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
254 rec
.data_len
, parser
, private_data
);
256 tdb_unlock(tdb
, BUCKET(rec
.full_hash
), F_RDLCK
);
261 /* check if an entry in the database exists
263 note that 1 is returned if the key is found and 0 is returned if not found
264 this doesn't match the conventions in the rest of this module, but is
267 static int tdb_exists_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
)
269 struct tdb_record rec
;
271 if (tdb_find_lock_hash(tdb
, key
, hash
, F_RDLCK
, &rec
) == 0)
273 tdb_unlock(tdb
, BUCKET(rec
.full_hash
), F_RDLCK
);
277 _PUBLIC_
int tdb_exists(struct tdb_context
*tdb
, TDB_DATA key
)
279 uint32_t hash
= tdb
->hash_fn(&key
);
282 ret
= tdb_exists_hash(tdb
, key
, hash
);
283 tdb_trace_1rec_ret(tdb
, "tdb_exists", key
, ret
);
287 /* actually delete an entry in the database given the offset */
288 int tdb_do_delete(struct tdb_context
*tdb
, tdb_off_t rec_ptr
, struct tdb_record
*rec
)
290 tdb_off_t last_ptr
, i
;
291 struct tdb_record lastrec
;
293 if (tdb
->read_only
|| tdb
->traverse_read
) return -1;
295 if (((tdb
->traverse_write
!= 0) && (!TDB_DEAD(rec
))) ||
296 tdb_write_lock_record(tdb
, rec_ptr
) == -1) {
297 /* Someone traversing here: mark it as dead */
298 rec
->magic
= TDB_DEAD_MAGIC
;
299 return tdb_rec_write(tdb
, rec_ptr
, rec
);
301 if (tdb_write_unlock_record(tdb
, rec_ptr
) != 0)
304 /* find previous record in hash chain */
305 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(rec
->full_hash
), &i
) == -1)
307 for (last_ptr
= 0; i
!= rec_ptr
; last_ptr
= i
, i
= lastrec
.next
)
308 if (tdb_rec_read(tdb
, i
, &lastrec
) == -1)
311 /* unlink it: next ptr is at start of record. */
313 last_ptr
= TDB_HASH_TOP(rec
->full_hash
);
314 if (tdb_ofs_write(tdb
, last_ptr
, &rec
->next
) == -1)
317 /* recover the space */
318 if (tdb_free(tdb
, rec_ptr
, rec
) == -1)
323 static int tdb_count_dead(struct tdb_context
*tdb
, uint32_t hash
)
327 struct tdb_record rec
;
329 /* read in the hash top */
330 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(hash
), &rec_ptr
) == -1)
334 if (tdb_rec_read(tdb
, rec_ptr
, &rec
) == -1)
337 if (rec
.magic
== TDB_DEAD_MAGIC
) {
346 * Purge all DEAD records from a hash chain
348 int tdb_purge_dead(struct tdb_context
*tdb
, uint32_t hash
)
351 struct tdb_record rec
;
354 if (tdb_lock_nonblock(tdb
, -1, F_WRLCK
) == -1) {
356 * Don't block the freelist if not strictly necessary
361 /* read in the hash top */
362 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(hash
), &rec_ptr
) == -1)
368 if (tdb_rec_read(tdb
, rec_ptr
, &rec
) == -1) {
374 if (rec
.magic
== TDB_DEAD_MAGIC
375 && tdb_do_delete(tdb
, rec_ptr
, &rec
) == -1) {
382 tdb_unlock(tdb
, -1, F_WRLCK
);
386 /* delete an entry in the database given a key */
387 static int tdb_delete_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
)
390 struct tdb_record rec
;
393 rec_ptr
= tdb_find_lock_hash(tdb
, key
, hash
, F_WRLCK
, &rec
);
398 if (tdb
->max_dead_records
!= 0) {
400 uint32_t magic
= TDB_DEAD_MAGIC
;
403 * Allow for some dead records per hash chain, mainly for
404 * tdb's with a very high create/delete rate like locking.tdb.
407 if (tdb_count_dead(tdb
, hash
) >= tdb
->max_dead_records
) {
409 * Don't let the per-chain freelist grow too large,
410 * delete all existing dead records
412 tdb_purge_dead(tdb
, hash
);
416 * Just mark the record as dead.
419 tdb
, rec_ptr
+ offsetof(struct tdb_record
, magic
),
423 ret
= tdb_do_delete(tdb
, rec_ptr
, &rec
);
427 tdb_increment_seqnum(tdb
);
430 if (tdb_unlock(tdb
, BUCKET(hash
), F_WRLCK
) != 0)
431 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "tdb_delete: WARNING tdb_unlock failed!\n"));
435 _PUBLIC_
int tdb_delete(struct tdb_context
*tdb
, TDB_DATA key
)
437 uint32_t hash
= tdb
->hash_fn(&key
);
440 ret
= tdb_delete_hash(tdb
, key
, hash
);
441 tdb_trace_1rec_ret(tdb
, "tdb_delete", key
, ret
);
446 * See if we have a dead record around with enough space
448 tdb_off_t
tdb_find_dead(struct tdb_context
*tdb
, uint32_t hash
,
449 struct tdb_record
*r
, tdb_len_t length
,
450 tdb_off_t
*p_last_ptr
)
452 tdb_off_t rec_ptr
, last_ptr
;
453 tdb_off_t best_rec_ptr
= 0;
454 tdb_off_t best_last_ptr
= 0;
455 struct tdb_record best
= { .rec_len
= UINT32_MAX
};
457 length
+= sizeof(tdb_off_t
); /* tailer */
459 last_ptr
= TDB_HASH_TOP(hash
);
461 /* read in the hash top */
462 if (tdb_ofs_read(tdb
, last_ptr
, &rec_ptr
) == -1)
465 /* keep looking until we find the right record */
467 if (tdb_rec_read(tdb
, rec_ptr
, r
) == -1)
470 if (TDB_DEAD(r
) && (r
->rec_len
>= length
) &&
471 (r
->rec_len
< best
.rec_len
)) {
472 best_rec_ptr
= rec_ptr
;
473 best_last_ptr
= last_ptr
;
480 if (best
.rec_len
== UINT32_MAX
) {
485 *p_last_ptr
= best_last_ptr
;
489 static int _tdb_store(struct tdb_context
*tdb
, TDB_DATA key
,
490 TDB_DATA dbuf
, int flag
, uint32_t hash
)
492 struct tdb_record rec
;
496 /* check for it existing, on insert. */
497 if (flag
== TDB_INSERT
) {
498 if (tdb_exists_hash(tdb
, key
, hash
)) {
499 tdb
->ecode
= TDB_ERR_EXISTS
;
503 /* first try in-place update, on modify or replace. */
504 if (tdb_update_hash(tdb
, key
, hash
, dbuf
) == 0) {
507 if (tdb
->ecode
== TDB_ERR_NOEXIST
&&
508 flag
== TDB_MODIFY
) {
509 /* if the record doesn't exist and we are in TDB_MODIFY mode then
510 we should fail the store */
514 /* reset the error code potentially set by the tdb_update() */
515 tdb
->ecode
= TDB_SUCCESS
;
517 /* delete any existing record - if it doesn't exist we don't
518 care. Doing this first reduces fragmentation, and avoids
519 coalescing with `allocated' block before it's updated. */
520 if (flag
!= TDB_INSERT
)
521 tdb_delete_hash(tdb
, key
, hash
);
523 /* we have to allocate some space */
524 rec_ptr
= tdb_allocate(tdb
, hash
, key
.dsize
+ dbuf
.dsize
, &rec
);
530 /* Read hash top into next ptr */
531 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(hash
), &rec
.next
) == -1)
534 rec
.key_len
= key
.dsize
;
535 rec
.data_len
= dbuf
.dsize
;
536 rec
.full_hash
= hash
;
537 rec
.magic
= TDB_MAGIC
;
539 /* write out and point the top of the hash chain at it */
540 if (tdb_rec_write(tdb
, rec_ptr
, &rec
) == -1
541 || tdb
->methods
->tdb_write(tdb
, rec_ptr
+sizeof(rec
),
542 key
.dptr
, key
.dsize
) == -1
543 || tdb
->methods
->tdb_write(tdb
, rec_ptr
+sizeof(rec
)+key
.dsize
,
544 dbuf
.dptr
, dbuf
.dsize
) == -1
545 || tdb_ofs_write(tdb
, TDB_HASH_TOP(hash
), &rec_ptr
) == -1) {
546 /* Need to tdb_unallocate() here */
554 tdb_increment_seqnum(tdb
);
559 /* store an element in the database, replacing any existing element
562 return 0 on success, -1 on failure
564 _PUBLIC_
int tdb_store(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA dbuf
, int flag
)
569 if (tdb
->read_only
|| tdb
->traverse_read
) {
570 tdb
->ecode
= TDB_ERR_RDONLY
;
571 tdb_trace_2rec_flag_ret(tdb
, "tdb_store", key
, dbuf
, flag
, -1);
575 /* find which hash bucket it is in */
576 hash
= tdb
->hash_fn(&key
);
577 if (tdb_lock(tdb
, BUCKET(hash
), F_WRLCK
) == -1)
580 ret
= _tdb_store(tdb
, key
, dbuf
, flag
, hash
);
581 tdb_trace_2rec_flag_ret(tdb
, "tdb_store", key
, dbuf
, flag
, ret
);
582 tdb_unlock(tdb
, BUCKET(hash
), F_WRLCK
);
586 /* Append to an entry. Create if not exist. */
587 _PUBLIC_
int tdb_append(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA new_dbuf
)
593 /* find which hash bucket it is in */
594 hash
= tdb
->hash_fn(&key
);
595 if (tdb_lock(tdb
, BUCKET(hash
), F_WRLCK
) == -1)
598 dbuf
= _tdb_fetch(tdb
, key
);
600 if (dbuf
.dptr
== NULL
) {
601 dbuf
.dptr
= (unsigned char *)malloc(new_dbuf
.dsize
);
603 unsigned int new_len
= dbuf
.dsize
+ new_dbuf
.dsize
;
604 unsigned char *new_dptr
;
606 /* realloc '0' is special: don't do that. */
609 new_dptr
= (unsigned char *)realloc(dbuf
.dptr
, new_len
);
610 if (new_dptr
== NULL
) {
613 dbuf
.dptr
= new_dptr
;
616 if (dbuf
.dptr
== NULL
) {
617 tdb
->ecode
= TDB_ERR_OOM
;
621 memcpy(dbuf
.dptr
+ dbuf
.dsize
, new_dbuf
.dptr
, new_dbuf
.dsize
);
622 dbuf
.dsize
+= new_dbuf
.dsize
;
624 ret
= _tdb_store(tdb
, key
, dbuf
, 0, hash
);
625 tdb_trace_2rec_retrec(tdb
, "tdb_append", key
, new_dbuf
, dbuf
);
628 tdb_unlock(tdb
, BUCKET(hash
), F_WRLCK
);
629 SAFE_FREE(dbuf
.dptr
);
635 return the name of the current tdb file
636 useful for external logging functions
638 _PUBLIC_
const char *tdb_name(struct tdb_context
*tdb
)
644 return the underlying file descriptor being used by tdb, or -1
645 useful for external routines that want to check the device/inode
648 _PUBLIC_
int tdb_fd(struct tdb_context
*tdb
)
654 return the current logging function
655 useful for external tdb routines that wish to log tdb errors
657 _PUBLIC_ tdb_log_func
tdb_log_fn(struct tdb_context
*tdb
)
659 return tdb
->log
.log_fn
;
664 get the tdb sequence number. Only makes sense if the writers opened
665 with TDB_SEQNUM set. Note that this sequence number will wrap quite
666 quickly, so it should only be used for a 'has something changed'
667 test, not for code that relies on the count of the number of changes
668 made. If you want a counter then use a tdb record.
670 The aim of this sequence number is to allow for a very lightweight
671 test of a possible tdb change.
673 _PUBLIC_
int tdb_get_seqnum(struct tdb_context
*tdb
)
677 tdb_ofs_read(tdb
, TDB_SEQNUM_OFS
, &seqnum
);
681 _PUBLIC_
int tdb_hash_size(struct tdb_context
*tdb
)
683 return tdb
->hash_size
;
686 _PUBLIC_
size_t tdb_map_size(struct tdb_context
*tdb
)
688 return tdb
->map_size
;
691 _PUBLIC_
int tdb_get_flags(struct tdb_context
*tdb
)
696 _PUBLIC_
void tdb_add_flags(struct tdb_context
*tdb
, unsigned flags
)
698 if ((flags
& TDB_ALLOW_NESTING
) &&
699 (flags
& TDB_DISALLOW_NESTING
)) {
700 tdb
->ecode
= TDB_ERR_NESTING
;
701 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_add_flags: "
702 "allow_nesting and disallow_nesting are not allowed together!"));
706 if (flags
& TDB_ALLOW_NESTING
) {
707 tdb
->flags
&= ~TDB_DISALLOW_NESTING
;
709 if (flags
& TDB_DISALLOW_NESTING
) {
710 tdb
->flags
&= ~TDB_ALLOW_NESTING
;
716 _PUBLIC_
void tdb_remove_flags(struct tdb_context
*tdb
, unsigned flags
)
718 if ((flags
& TDB_ALLOW_NESTING
) &&
719 (flags
& TDB_DISALLOW_NESTING
)) {
720 tdb
->ecode
= TDB_ERR_NESTING
;
721 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_remove_flags: "
722 "allow_nesting and disallow_nesting are not allowed together!"));
726 if (flags
& TDB_ALLOW_NESTING
) {
727 tdb
->flags
|= TDB_DISALLOW_NESTING
;
729 if (flags
& TDB_DISALLOW_NESTING
) {
730 tdb
->flags
|= TDB_ALLOW_NESTING
;
733 tdb
->flags
&= ~flags
;
738 enable sequence number handling on an open tdb
740 _PUBLIC_
void tdb_enable_seqnum(struct tdb_context
*tdb
)
742 tdb
->flags
|= TDB_SEQNUM
;
747 add a region of the file to the freelist. Length is the size of the region in bytes,
748 which includes the free list header that needs to be added
750 static int tdb_free_region(struct tdb_context
*tdb
, tdb_off_t offset
, ssize_t length
)
752 struct tdb_record rec
;
753 if (length
<= sizeof(rec
)) {
754 /* the region is not worth adding */
757 if (length
+ offset
> tdb
->map_size
) {
758 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_free_region: adding region beyond end of file\n"));
761 memset(&rec
,'\0',sizeof(rec
));
762 rec
.rec_len
= length
- sizeof(rec
);
763 if (tdb_free(tdb
, offset
, &rec
) == -1) {
764 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_free_region: failed to add free record\n"));
771 wipe the entire database, deleting all records. This can be done
772 very fast by using a allrecord lock. The entire data portion of the
773 file becomes a single entry in the freelist.
775 This code carefully steps around the recovery area, leaving it alone
777 _PUBLIC_
int tdb_wipe_all(struct tdb_context
*tdb
)
780 tdb_off_t offset
= 0;
782 tdb_off_t recovery_head
;
783 tdb_len_t recovery_size
= 0;
785 if (tdb_lockall(tdb
) != 0) {
789 tdb_trace(tdb
, "tdb_wipe_all");
791 /* see if the tdb has a recovery area, and remember its size
792 if so. We don't want to lose this as otherwise each
793 tdb_wipe_all() in a transaction will increase the size of
794 the tdb by the size of the recovery area */
795 if (tdb_ofs_read(tdb
, TDB_RECOVERY_HEAD
, &recovery_head
) == -1) {
796 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_wipe_all: failed to read recovery head\n"));
800 if (recovery_head
!= 0) {
801 struct tdb_record rec
;
802 if (tdb
->methods
->tdb_read(tdb
, recovery_head
, &rec
, sizeof(rec
), DOCONV()) == -1) {
803 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_wipe_all: failed to read recovery record\n"));
806 recovery_size
= rec
.rec_len
+ sizeof(rec
);
809 /* wipe the hashes */
810 for (i
=0;i
<tdb
->hash_size
;i
++) {
811 if (tdb_ofs_write(tdb
, TDB_HASH_TOP(i
), &offset
) == -1) {
812 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_wipe_all: failed to write hash %d\n", i
));
817 /* wipe the freelist */
818 if (tdb_ofs_write(tdb
, FREELIST_TOP
, &offset
) == -1) {
819 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_wipe_all: failed to write freelist\n"));
823 /* add all the rest of the file to the freelist, possibly leaving a gap
824 for the recovery area */
825 if (recovery_size
== 0) {
826 /* the simple case - the whole file can be used as a freelist */
827 data_len
= (tdb
->map_size
- TDB_DATA_START(tdb
->hash_size
));
828 if (tdb_free_region(tdb
, TDB_DATA_START(tdb
->hash_size
), data_len
) != 0) {
832 /* we need to add two freelist entries - one on either
833 side of the recovery area
835 Note that we cannot shift the recovery area during
836 this operation. Only the transaction.c code may
837 move the recovery area or we risk subtle data
840 data_len
= (recovery_head
- TDB_DATA_START(tdb
->hash_size
));
841 if (tdb_free_region(tdb
, TDB_DATA_START(tdb
->hash_size
), data_len
) != 0) {
844 /* and the 2nd free list entry after the recovery area - if any */
845 data_len
= tdb
->map_size
- (recovery_head
+recovery_size
);
846 if (tdb_free_region(tdb
, recovery_head
+recovery_size
, data_len
) != 0) {
851 tdb_increment_seqnum_nonblock(tdb
);
853 if (tdb_unlockall(tdb
) != 0) {
854 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_wipe_all: failed to unlock\n"));
865 struct traverse_state
{
867 struct tdb_context
*dest_db
;
871 traverse function for repacking
873 static int repack_traverse(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA data
, void *private_data
)
875 struct traverse_state
*state
= (struct traverse_state
*)private_data
;
876 if (tdb_store(state
->dest_db
, key
, data
, TDB_INSERT
) != 0) {
886 _PUBLIC_
int tdb_repack(struct tdb_context
*tdb
)
888 struct tdb_context
*tmp_db
;
889 struct traverse_state state
;
891 tdb_trace(tdb
, "tdb_repack");
893 if (tdb_transaction_start(tdb
) != 0) {
894 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to start transaction\n"));
898 tmp_db
= tdb_open("tmpdb", tdb_hash_size(tdb
), TDB_INTERNAL
, O_RDWR
|O_CREAT
, 0);
899 if (tmp_db
== NULL
) {
900 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to create tmp_db\n"));
901 tdb_transaction_cancel(tdb
);
906 state
.dest_db
= tmp_db
;
908 if (tdb_traverse_read(tdb
, repack_traverse
, &state
) == -1) {
909 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to traverse copying out\n"));
910 tdb_transaction_cancel(tdb
);
916 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Error during traversal\n"));
917 tdb_transaction_cancel(tdb
);
922 if (tdb_wipe_all(tdb
) != 0) {
923 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to wipe database\n"));
924 tdb_transaction_cancel(tdb
);
932 if (tdb_traverse_read(tmp_db
, repack_traverse
, &state
) == -1) {
933 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to traverse copying back\n"));
934 tdb_transaction_cancel(tdb
);
940 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Error during second traversal\n"));
941 tdb_transaction_cancel(tdb
);
948 if (tdb_transaction_commit(tdb
) != 0) {
949 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, __location__
" Failed to commit\n"));
956 /* Even on files, we can get partial writes due to signals. */
957 bool tdb_write_all(int fd
, const void *buf
, size_t count
)
961 ret
= write(fd
, buf
, count
);
964 buf
= (const char *)buf
+ ret
;
970 bool tdb_add_off_t(tdb_off_t a
, tdb_off_t b
, tdb_off_t
*pret
)
972 tdb_off_t ret
= a
+ b
;
974 if ((ret
< a
) || (ret
< b
)) {
982 static void tdb_trace_write(struct tdb_context
*tdb
, const char *str
)
984 if (!tdb_write_all(tdb
->tracefd
, str
, strlen(str
))) {
990 static void tdb_trace_start(struct tdb_context
*tdb
)
993 char msg
[sizeof(tdb_off_t
) * 4 + 1];
995 tdb_ofs_read(tdb
, TDB_SEQNUM_OFS
, &seqnum
);
996 snprintf(msg
, sizeof(msg
), "%u ", seqnum
);
997 tdb_trace_write(tdb
, msg
);
1000 static void tdb_trace_end(struct tdb_context
*tdb
)
1002 tdb_trace_write(tdb
, "\n");
1005 static void tdb_trace_end_ret(struct tdb_context
*tdb
, int ret
)
1007 char msg
[sizeof(ret
) * 4 + 4];
1008 snprintf(msg
, sizeof(msg
), " = %i\n", ret
);
1009 tdb_trace_write(tdb
, msg
);
1012 static void tdb_trace_record(struct tdb_context
*tdb
, TDB_DATA rec
)
1014 char msg
[20 + rec
.dsize
*2], *p
;
1017 /* We differentiate zero-length records from non-existent ones. */
1018 if (rec
.dptr
== NULL
) {
1019 tdb_trace_write(tdb
, " NULL");
1023 /* snprintf here is purely cargo-cult programming. */
1025 p
+= snprintf(p
, sizeof(msg
), " %zu:", rec
.dsize
);
1026 for (i
= 0; i
< rec
.dsize
; i
++)
1027 p
+= snprintf(p
, 2, "%02x", rec
.dptr
[i
]);
1029 tdb_trace_write(tdb
, msg
);
1032 void tdb_trace(struct tdb_context
*tdb
, const char *op
)
1034 tdb_trace_start(tdb
);
1035 tdb_trace_write(tdb
, op
);
1039 void tdb_trace_seqnum(struct tdb_context
*tdb
, uint32_t seqnum
, const char *op
)
1041 char msg
[sizeof(tdb_off_t
) * 4 + 1];
1043 snprintf(msg
, sizeof(msg
), "%u ", seqnum
);
1044 tdb_trace_write(tdb
, msg
);
1045 tdb_trace_write(tdb
, op
);
1049 void tdb_trace_open(struct tdb_context
*tdb
, const char *op
,
1050 unsigned hash_size
, unsigned tdb_flags
, unsigned open_flags
)
1054 snprintf(msg
, sizeof(msg
),
1055 "%s %u 0x%x 0x%x", op
, hash_size
, tdb_flags
, open_flags
);
1056 tdb_trace_start(tdb
);
1057 tdb_trace_write(tdb
, msg
);
1061 void tdb_trace_ret(struct tdb_context
*tdb
, const char *op
, int ret
)
1063 tdb_trace_start(tdb
);
1064 tdb_trace_write(tdb
, op
);
1065 tdb_trace_end_ret(tdb
, ret
);
1068 void tdb_trace_retrec(struct tdb_context
*tdb
, const char *op
, TDB_DATA ret
)
1070 tdb_trace_start(tdb
);
1071 tdb_trace_write(tdb
, op
);
1072 tdb_trace_write(tdb
, " =");
1073 tdb_trace_record(tdb
, ret
);
1077 void tdb_trace_1rec(struct tdb_context
*tdb
, const char *op
,
1080 tdb_trace_start(tdb
);
1081 tdb_trace_write(tdb
, op
);
1082 tdb_trace_record(tdb
, rec
);
1086 void tdb_trace_1rec_ret(struct tdb_context
*tdb
, const char *op
,
1087 TDB_DATA rec
, int ret
)
1089 tdb_trace_start(tdb
);
1090 tdb_trace_write(tdb
, op
);
1091 tdb_trace_record(tdb
, rec
);
1092 tdb_trace_end_ret(tdb
, ret
);
1095 void tdb_trace_1rec_retrec(struct tdb_context
*tdb
, const char *op
,
1096 TDB_DATA rec
, TDB_DATA ret
)
1098 tdb_trace_start(tdb
);
1099 tdb_trace_write(tdb
, op
);
1100 tdb_trace_record(tdb
, rec
);
1101 tdb_trace_write(tdb
, " =");
1102 tdb_trace_record(tdb
, ret
);
1106 void tdb_trace_2rec_flag_ret(struct tdb_context
*tdb
, const char *op
,
1107 TDB_DATA rec1
, TDB_DATA rec2
, unsigned flag
,
1110 char msg
[1 + sizeof(ret
) * 4];
1112 snprintf(msg
, sizeof(msg
), " %#x", flag
);
1113 tdb_trace_start(tdb
);
1114 tdb_trace_write(tdb
, op
);
1115 tdb_trace_record(tdb
, rec1
);
1116 tdb_trace_record(tdb
, rec2
);
1117 tdb_trace_write(tdb
, msg
);
1118 tdb_trace_end_ret(tdb
, ret
);
1121 void tdb_trace_2rec_retrec(struct tdb_context
*tdb
, const char *op
,
1122 TDB_DATA rec1
, TDB_DATA rec2
, TDB_DATA ret
)
1124 tdb_trace_start(tdb
);
1125 tdb_trace_write(tdb
, op
);
1126 tdb_trace_record(tdb
, rec1
);
1127 tdb_trace_record(tdb
, rec2
);
1128 tdb_trace_write(tdb
, " =");
1129 tdb_trace_record(tdb
, ret
);