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"
33 non-blocking increment of the tdb sequence number if the tdb has been opened using
36 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_brlock(tdb, F_WRLCK, TDB_SEQNUM_OFS, 1,
63 TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
67 tdb_increment_seqnum_nonblock(tdb);
69 tdb_brunlock(tdb, F_WRLCK, TDB_SEQNUM_OFS, 1);
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,
80 struct list_struct *r)
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 list_struct *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);
126 /* update an entry in place - this only works if the new data size
127 is <= the old data size and the key exists.
128 on failure return -1.
130 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
132 struct list_struct rec;
136 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
139 /* must be long enough key, data and tailer */
140 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
141 tdb->ecode = TDB_SUCCESS; /* Not really an error */
145 if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
146 dbuf.dptr, dbuf.dsize) == -1)
149 if (dbuf.dsize != rec.data_len) {
151 rec.data_len = dbuf.dsize;
152 return tdb_rec_write(tdb, rec_ptr, &rec);
158 /* find an entry in the database given a key */
159 /* If an entry doesn't exist tdb_err will be set to
160 * TDB_ERR_NOEXIST. If a key has no data attached
161 * then the TDB_DATA will have zero length but
164 static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
167 struct list_struct rec;
171 /* find which hash bucket it is in */
172 hash = tdb->hash_fn(&key);
173 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
176 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
178 ret.dsize = rec.data_len;
179 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
183 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
185 TDB_DATA ret = _tdb_fetch(tdb, key);
187 tdb_trace_1rec_retrec(tdb, "tdb_fetch", key, ret);
192 * Find an entry in the database and hand the record's data to a parsing
193 * function. The parsing function is executed under the chain read lock, so it
194 * should be fast and should not block on other syscalls.
196 * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
198 * For mmapped tdb's that do not have a transaction open it points the parsing
199 * function directly at the mmap area, it avoids the malloc/memcpy in this
200 * case. If a transaction is open or no mmap is available, it has to do
201 * malloc/read/parse/free.
203 * This is interesting for all readers of potentially large data structures in
204 * the tdb records, ldb indexes being one example.
207 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
208 int (*parser)(TDB_DATA key, TDB_DATA data,
213 struct list_struct rec;
217 /* find which hash bucket it is in */
218 hash = tdb->hash_fn(&key);
220 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
221 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key,
223 tdb->ecode = TDB_ERR_NOEXIST;
226 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
228 ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
229 rec.data_len, parser, private_data);
231 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
236 /* check if an entry in the database exists
238 note that 1 is returned if the key is found and 0 is returned if not found
239 this doesn't match the conventions in the rest of this module, but is
242 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
244 struct list_struct rec;
246 if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
248 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
252 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
254 uint32_t hash = tdb->hash_fn(&key);
257 ret = tdb_exists_hash(tdb, key, hash);
258 tdb_trace_1rec_ret(tdb, "tdb_exists", key, ret);
262 /* actually delete an entry in the database given the offset */
263 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
265 tdb_off_t last_ptr, i;
266 struct list_struct lastrec;
268 if (tdb->read_only || tdb->traverse_read) return -1;
270 if (tdb->traverse_write != 0 ||
271 tdb_write_lock_record(tdb, rec_ptr) == -1) {
272 /* Someone traversing here: mark it as dead */
273 rec->magic = TDB_DEAD_MAGIC;
274 return tdb_rec_write(tdb, rec_ptr, rec);
276 if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
279 /* find previous record in hash chain */
280 if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
282 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
283 if (tdb_rec_read(tdb, i, &lastrec) == -1)
286 /* unlink it: next ptr is at start of record. */
288 last_ptr = TDB_HASH_TOP(rec->full_hash);
289 if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
292 /* recover the space */
293 if (tdb_free(tdb, rec_ptr, rec) == -1)
298 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
302 struct list_struct rec;
304 /* read in the hash top */
305 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
309 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
312 if (rec.magic == TDB_DEAD_MAGIC) {
321 * Purge all DEAD records from a hash chain
323 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
326 struct list_struct rec;
329 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
333 /* read in the hash top */
334 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
340 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
346 if (rec.magic == TDB_DEAD_MAGIC
347 && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
354 tdb_unlock(tdb, -1, F_WRLCK);
358 /* delete an entry in the database given a key */
359 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
362 struct list_struct rec;
365 if (tdb->max_dead_records != 0) {
368 * Allow for some dead records per hash chain, mainly for
369 * tdb's with a very high create/delete rate like locking.tdb.
372 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
375 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
377 * Don't let the per-chain freelist grow too large,
378 * delete all existing dead records
380 tdb_purge_dead(tdb, hash);
383 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
384 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
389 * Just mark the record as dead.
391 rec.magic = TDB_DEAD_MAGIC;
392 ret = tdb_rec_write(tdb, rec_ptr, &rec);
395 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
399 ret = tdb_do_delete(tdb, rec_ptr, &rec);
403 tdb_increment_seqnum(tdb);
406 if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
407 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
411 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
413 uint32_t hash = tdb->hash_fn(&key);
416 ret = tdb_delete_hash(tdb, key, hash);
417 tdb_trace_1rec_ret(tdb, "tdb_delete", key, ret);
422 * See if we have a dead record around with enough space
424 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
425 struct list_struct *r, tdb_len_t length)
429 /* read in the hash top */
430 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
433 /* keep looking until we find the right record */
435 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
438 if (TDB_DEAD(r) && r->rec_len >= length) {
440 * First fit for simple coding, TODO: change to best
450 static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
451 TDB_DATA dbuf, int flag, uint32_t hash)
453 struct list_struct rec;
458 /* check for it existing, on insert. */
459 if (flag == TDB_INSERT) {
460 if (tdb_exists_hash(tdb, key, hash)) {
461 tdb->ecode = TDB_ERR_EXISTS;
465 /* first try in-place update, on modify or replace. */
466 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
469 if (tdb->ecode == TDB_ERR_NOEXIST &&
470 flag == TDB_MODIFY) {
471 /* if the record doesn't exist and we are in TDB_MODIFY mode then
472 we should fail the store */
476 /* reset the error code potentially set by the tdb_update() */
477 tdb->ecode = TDB_SUCCESS;
479 /* delete any existing record - if it doesn't exist we don't
480 care. Doing this first reduces fragmentation, and avoids
481 coalescing with `allocated' block before it's updated. */
482 if (flag != TDB_INSERT)
483 tdb_delete_hash(tdb, key, hash);
485 /* Copy key+value *before* allocating free space in case malloc
486 fails and we are left with a dead spot in the tdb. */
488 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
489 tdb->ecode = TDB_ERR_OOM;
493 memcpy(p, key.dptr, key.dsize);
495 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
497 if (tdb->max_dead_records != 0) {
499 * Allow for some dead records per hash chain, look if we can
500 * find one that can hold the new record. We need enough space
501 * for key, data and tailer. If we find one, we don't have to
502 * consult the central freelist.
504 rec_ptr = tdb_find_dead(
506 key.dsize + dbuf.dsize + sizeof(tdb_off_t));
509 rec.key_len = key.dsize;
510 rec.data_len = dbuf.dsize;
511 rec.full_hash = hash;
512 rec.magic = TDB_MAGIC;
513 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
514 || tdb->methods->tdb_write(
515 tdb, rec_ptr + sizeof(rec),
516 p, key.dsize + dbuf.dsize) == -1) {
524 * We have to allocate some space from the freelist, so this means we
525 * have to lock it. Use the chance to purge all the DEAD records from
526 * the hash chain under the freelist lock.
529 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
533 if ((tdb->max_dead_records != 0)
534 && (tdb_purge_dead(tdb, hash) == -1)) {
535 tdb_unlock(tdb, -1, F_WRLCK);
539 /* we have to allocate some space */
540 rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
542 tdb_unlock(tdb, -1, F_WRLCK);
548 /* Read hash top into next ptr */
549 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
552 rec.key_len = key.dsize;
553 rec.data_len = dbuf.dsize;
554 rec.full_hash = hash;
555 rec.magic = TDB_MAGIC;
557 /* write out and point the top of the hash chain at it */
558 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
559 || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
560 || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
561 /* Need to tdb_unallocate() here */
569 tdb_increment_seqnum(tdb);
576 /* store an element in the database, replacing any existing element
579 return 0 on success, -1 on failure
581 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
586 if (tdb->read_only || tdb->traverse_read) {
587 tdb->ecode = TDB_ERR_RDONLY;
588 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag,
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 ret = _tdb_store(tdb, key, dbuf, flag, hash);
599 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag, ret);
600 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
605 /* Append to an entry. Create if not exist. */
606 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
612 /* find which hash bucket it is in */
613 hash = tdb->hash_fn(&key);
614 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
617 dbuf = _tdb_fetch(tdb, key);
619 if (dbuf.dptr == NULL) {
620 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
622 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
623 unsigned char *new_dptr;
625 /* realloc '0' is special: don't do that. */
628 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
629 if (new_dptr == NULL) {
632 dbuf.dptr = new_dptr;
635 if (dbuf.dptr == NULL) {
636 tdb->ecode = TDB_ERR_OOM;
640 memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
641 dbuf.dsize += new_dbuf.dsize;
643 ret = _tdb_store(tdb, key, dbuf, 0, hash);
644 tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
647 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
648 SAFE_FREE(dbuf.dptr);
654 return the name of the current tdb file
655 useful for external logging functions
657 const char *tdb_name(struct tdb_context *tdb)
663 return the underlying file descriptor being used by tdb, or -1
664 useful for external routines that want to check the device/inode
667 int tdb_fd(struct tdb_context *tdb)
673 return the current logging function
674 useful for external tdb routines that wish to log tdb errors
676 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
678 return tdb->log.log_fn;
683 get the tdb sequence number. Only makes sense if the writers opened
684 with TDB_SEQNUM set. Note that this sequence number will wrap quite
685 quickly, so it should only be used for a 'has something changed'
686 test, not for code that relies on the count of the number of changes
687 made. If you want a counter then use a tdb record.
689 The aim of this sequence number is to allow for a very lightweight
690 test of a possible tdb change.
692 int tdb_get_seqnum(struct tdb_context *tdb)
696 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
697 tdb_trace_ret(tdb, "tdb_get_seqnum", seqnum);
701 int tdb_hash_size(struct tdb_context *tdb)
703 return tdb->header.hash_size;
706 size_t tdb_map_size(struct tdb_context *tdb)
708 return tdb->map_size;
711 int tdb_get_flags(struct tdb_context *tdb)
716 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
721 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
723 tdb->flags &= ~flags;
728 enable sequence number handling on an open tdb
730 void tdb_enable_seqnum(struct tdb_context *tdb)
732 tdb->flags |= TDB_SEQNUM;
737 add a region of the file to the freelist. Length is the size of the region in bytes,
738 which includes the free list header that needs to be added
740 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
742 struct list_struct rec;
743 if (length <= sizeof(rec)) {
744 /* the region is not worth adding */
747 if (length + offset > tdb->map_size) {
748 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
751 memset(&rec,'\0',sizeof(rec));
752 rec.rec_len = length - sizeof(rec);
753 if (tdb_free(tdb, offset, &rec) == -1) {
754 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
761 wipe the entire database, deleting all records. This can be done
762 very fast by using a global lock. The entire data portion of the
763 file becomes a single entry in the freelist.
765 This code carefully steps around the recovery area, leaving it alone
767 int tdb_wipe_all(struct tdb_context *tdb)
770 tdb_off_t offset = 0;
772 tdb_off_t recovery_head;
773 tdb_len_t recovery_size = 0;
775 if (tdb_lockall(tdb) != 0) {
779 tdb_trace(tdb, "tdb_wipe_all");
781 /* see if the tdb has a recovery area, and remember its size
782 if so. We don't want to lose this as otherwise each
783 tdb_wipe_all() in a transaction will increase the size of
784 the tdb by the size of the recovery area */
785 if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
786 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
790 if (recovery_head != 0) {
791 struct list_struct rec;
792 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
793 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
796 recovery_size = rec.rec_len + sizeof(rec);
799 /* wipe the hashes */
800 for (i=0;i<tdb->header.hash_size;i++) {
801 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
802 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
807 /* wipe the freelist */
808 if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
809 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
813 /* add all the rest of the file to the freelist, possibly leaving a gap
814 for the recovery area */
815 if (recovery_size == 0) {
816 /* the simple case - the whole file can be used as a freelist */
817 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
818 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
822 /* we need to add two freelist entries - one on either
823 side of the recovery area
825 Note that we cannot shift the recovery area during
826 this operation. Only the transaction.c code may
827 move the recovery area or we risk subtle data
830 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
831 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
834 /* and the 2nd free list entry after the recovery area - if any */
835 data_len = tdb->map_size - (recovery_head+recovery_size);
836 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
841 if (tdb_unlockall(tdb) != 0) {
842 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
854 struct traverse_state {
856 struct tdb_context *dest_db;
860 traverse function for repacking
862 static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private)
864 struct traverse_state *state = (struct traverse_state *)private;
865 if (tdb_store(state->dest_db, key, data, TDB_INSERT) != 0) {
875 int tdb_repack(struct tdb_context *tdb)
877 struct tdb_context *tmp_db;
878 struct traverse_state state;
880 tdb_trace(tdb, "tdb_repack");
882 if (tdb_transaction_start(tdb) != 0) {
883 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to start transaction\n"));
887 tmp_db = tdb_open("tmpdb", tdb_hash_size(tdb), TDB_INTERNAL, O_RDWR|O_CREAT, 0);
888 if (tmp_db == NULL) {
889 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to create tmp_db\n"));
890 tdb_transaction_cancel(tdb);
895 state.dest_db = tmp_db;
897 if (tdb_traverse_read(tdb, repack_traverse, &state) == -1) {
898 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying out\n"));
899 tdb_transaction_cancel(tdb);
905 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during traversal\n"));
906 tdb_transaction_cancel(tdb);
911 if (tdb_wipe_all(tdb) != 0) {
912 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to wipe database\n"));
913 tdb_transaction_cancel(tdb);
921 if (tdb_traverse_read(tmp_db, repack_traverse, &state) == -1) {
922 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying back\n"));
923 tdb_transaction_cancel(tdb);
929 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during second traversal\n"));
930 tdb_transaction_cancel(tdb);
937 if (tdb_transaction_commit(tdb) != 0) {
938 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to commit\n"));
946 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
948 if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
954 static void tdb_trace_start(struct tdb_context *tdb)
957 char msg[sizeof(tdb_off_t) * 4];
959 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
960 sprintf(msg, "%u ", seqnum);
961 tdb_trace_write(tdb, msg);
964 static void tdb_trace_end(struct tdb_context *tdb)
966 tdb_trace_write(tdb, "\n");
969 static void tdb_trace_end_ret(struct tdb_context *tdb, int ret)
971 char msg[sizeof(ret) * 4];
972 sprintf(msg, " = %i\n", ret);
973 tdb_trace_write(tdb, msg);
976 static void tdb_trace_record(struct tdb_context *tdb, TDB_DATA rec)
978 char msg[20 + rec.dsize*2], *p;
981 /* We differentiate zero-length records from non-existent ones. */
982 if (rec.dptr == NULL) {
983 tdb_trace_write(tdb, " NULL");
988 p += sprintf(p, " %zu:", rec.dsize);
989 for (i = 0; i < rec.dsize; i++)
990 p += sprintf(p, "%02x", rec.dptr[i]);
992 tdb_trace_write(tdb, msg);
995 void tdb_trace(struct tdb_context *tdb, const char *op)
997 tdb_trace_start(tdb);
998 tdb_trace_write(tdb, op);
1002 void tdb_trace_seqnum(struct tdb_context *tdb, uint32_t seqnum, const char *op)
1004 char msg[sizeof(tdb_off_t) * 4];
1006 sprintf(msg, "%u ", seqnum);
1007 tdb_trace_write(tdb, msg);
1008 tdb_trace_write(tdb, op);
1012 void tdb_trace_open(struct tdb_context *tdb, const char *op,
1013 unsigned hash_size, unsigned tdb_flags, unsigned open_flags)
1017 sprintf(msg, "%s %u %#x %#x", op, hash_size, tdb_flags, open_flags);
1018 tdb_trace_start(tdb);
1019 tdb_trace_write(tdb, msg);
1023 void tdb_trace_ret(struct tdb_context *tdb, const char *op, int ret)
1025 tdb_trace_start(tdb);
1026 tdb_trace_write(tdb, op);
1027 tdb_trace_end_ret(tdb, ret);
1030 void tdb_trace_retrec(struct tdb_context *tdb, const char *op, TDB_DATA ret)
1032 tdb_trace_start(tdb);
1033 tdb_trace_write(tdb, op);
1034 tdb_trace_write(tdb, " =");
1035 tdb_trace_record(tdb, ret);
1039 void tdb_trace_1rec(struct tdb_context *tdb, const char *op,
1042 tdb_trace_start(tdb);
1043 tdb_trace_write(tdb, op);
1044 tdb_trace_record(tdb, rec);
1048 void tdb_trace_1rec_ret(struct tdb_context *tdb, const char *op,
1049 TDB_DATA rec, int ret)
1051 tdb_trace_start(tdb);
1052 tdb_trace_write(tdb, op);
1053 tdb_trace_record(tdb, rec);
1054 tdb_trace_end_ret(tdb, ret);
1057 void tdb_trace_1rec_retrec(struct tdb_context *tdb, const char *op,
1058 TDB_DATA rec, TDB_DATA ret)
1060 tdb_trace_start(tdb);
1061 tdb_trace_write(tdb, op);
1062 tdb_trace_record(tdb, rec);
1063 tdb_trace_write(tdb, " =");
1064 tdb_trace_record(tdb, ret);
1068 void tdb_trace_2rec_flag_ret(struct tdb_context *tdb, const char *op,
1069 TDB_DATA rec1, TDB_DATA rec2, unsigned flag,
1072 char msg[sizeof(ret) * 4];
1074 sprintf(msg, " %#x", flag);
1075 tdb_trace_start(tdb);
1076 tdb_trace_write(tdb, op);
1077 tdb_trace_record(tdb, rec1);
1078 tdb_trace_record(tdb, rec2);
1079 tdb_trace_write(tdb, msg);
1080 tdb_trace_end_ret(tdb, ret);
1083 void tdb_trace_2rec_retrec(struct tdb_context *tdb, const char *op,
1084 TDB_DATA rec1, TDB_DATA rec2, TDB_DATA ret)
1086 tdb_trace_start(tdb);
1087 tdb_trace_write(tdb, op);
1088 tdb_trace_record(tdb, rec1);
1089 tdb_trace_record(tdb, rec2);
1090 tdb_trace_write(tdb, " =");
1091 tdb_trace_record(tdb, ret);