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, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
66 tdb_increment_seqnum_nonblock(tdb);
68 tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
71 static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
73 return memcmp(data.dptr, key.dptr, data.dsize);
76 /* Returns 0 on fail. On success, return offset of record, and fills
78 static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
79 struct list_struct *r)
83 /* read in the hash top */
84 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
87 /* keep looking until we find the right record */
89 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
92 if (!TDB_DEAD(r) && hash==r->full_hash
93 && key.dsize==r->key_len
94 && tdb_parse_data(tdb, key, rec_ptr + sizeof(*r),
95 r->key_len, tdb_key_compare,
99 /* detect tight infinite loop */
100 if (rec_ptr == r->next) {
101 tdb->ecode = TDB_ERR_CORRUPT;
102 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_find: loop detected.\n"));
107 tdb->ecode = TDB_ERR_NOEXIST;
111 /* As tdb_find, but if you succeed, keep the lock */
112 tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
113 struct list_struct *rec)
117 if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
119 if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
120 tdb_unlock(tdb, BUCKET(hash), locktype);
125 /* update an entry in place - this only works if the new data size
126 is <= the old data size and the key exists.
127 on failure return -1.
129 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
131 struct list_struct rec;
135 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
138 /* must be long enough key, data and tailer */
139 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
140 tdb->ecode = TDB_SUCCESS; /* Not really an error */
144 if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
145 dbuf.dptr, dbuf.dsize) == -1)
148 if (dbuf.dsize != rec.data_len) {
150 rec.data_len = dbuf.dsize;
151 return tdb_rec_write(tdb, rec_ptr, &rec);
157 /* find an entry in the database given a key */
158 /* If an entry doesn't exist tdb_err will be set to
159 * TDB_ERR_NOEXIST. If a key has no data attached
160 * then the TDB_DATA will have zero length but
163 static TDB_DATA do_tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
166 struct list_struct rec;
170 /* find which hash bucket it is in */
171 hash = tdb->hash_fn(&key);
172 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
175 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
177 ret.dsize = rec.data_len;
178 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
182 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
184 TDB_DATA ret = do_tdb_fetch(tdb, key);
186 tdb_trace_1rec_retrec(tdb, "tdb_fetch", key, ret);
191 * Find an entry in the database and hand the record's data to a parsing
192 * function. The parsing function is executed under the chain read lock, so it
193 * should be fast and should not block on other syscalls.
195 * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
197 * For mmapped tdb's that do not have a transaction open it points the parsing
198 * function directly at the mmap area, it avoids the malloc/memcpy in this
199 * case. If a transaction is open or no mmap is available, it has to do
200 * malloc/read/parse/free.
202 * This is interesting for all readers of potentially large data structures in
203 * the tdb records, ldb indexes being one example.
206 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
207 int (*parser)(TDB_DATA key, TDB_DATA data,
212 struct list_struct rec;
216 /* find which hash bucket it is in */
217 hash = tdb->hash_fn(&key);
219 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
220 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key,
222 tdb->ecode = TDB_ERR_NOEXIST;
225 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
227 ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
228 rec.data_len, parser, private_data);
230 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
235 /* check if an entry in the database exists
237 note that 1 is returned if the key is found and 0 is returned if not found
238 this doesn't match the conventions in the rest of this module, but is
241 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
243 struct list_struct rec;
245 if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
247 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
251 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
253 uint32_t hash = tdb->hash_fn(&key);
256 ret = tdb_exists_hash(tdb, key, hash);
257 tdb_trace_1rec_ret(tdb, "tdb_exists", key, ret);
261 /* actually delete an entry in the database given the offset */
262 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
264 tdb_off_t last_ptr, i;
265 struct list_struct lastrec;
267 if (tdb->read_only || tdb->traverse_read) return -1;
269 if (tdb->traverse_write != 0 ||
270 tdb_write_lock_record(tdb, rec_ptr) == -1) {
271 /* Someone traversing here: mark it as dead */
272 rec->magic = TDB_DEAD_MAGIC;
273 return tdb_rec_write(tdb, rec_ptr, rec);
275 if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
278 /* find previous record in hash chain */
279 if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
281 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
282 if (tdb_rec_read(tdb, i, &lastrec) == -1)
285 /* unlink it: next ptr is at start of record. */
287 last_ptr = TDB_HASH_TOP(rec->full_hash);
288 if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
291 /* recover the space */
292 if (tdb_free(tdb, rec_ptr, rec) == -1)
297 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
301 struct list_struct rec;
303 /* read in the hash top */
304 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
308 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
311 if (rec.magic == TDB_DEAD_MAGIC) {
320 * Purge all DEAD records from a hash chain
322 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
325 struct list_struct rec;
328 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
332 /* read in the hash top */
333 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
339 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
345 if (rec.magic == TDB_DEAD_MAGIC
346 && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
353 tdb_unlock(tdb, -1, F_WRLCK);
357 /* delete an entry in the database given a key */
358 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
361 struct list_struct rec;
364 if (tdb->max_dead_records != 0) {
367 * Allow for some dead records per hash chain, mainly for
368 * tdb's with a very high create/delete rate like locking.tdb.
371 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
374 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
376 * Don't let the per-chain freelist grow too large,
377 * delete all existing dead records
379 tdb_purge_dead(tdb, hash);
382 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
383 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
388 * Just mark the record as dead.
390 rec.magic = TDB_DEAD_MAGIC;
391 ret = tdb_rec_write(tdb, rec_ptr, &rec);
394 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
398 ret = tdb_do_delete(tdb, rec_ptr, &rec);
402 tdb_increment_seqnum(tdb);
405 if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
406 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
410 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
412 uint32_t hash = tdb->hash_fn(&key);
415 ret = tdb_delete_hash(tdb, key, hash);
416 tdb_trace_1rec_ret(tdb, "tdb_delete", key, ret);
421 * See if we have a dead record around with enough space
423 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
424 struct list_struct *r, tdb_len_t length)
428 /* read in the hash top */
429 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
432 /* keep looking until we find the right record */
434 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
437 if (TDB_DEAD(r) && r->rec_len >= length) {
439 * First fit for simple coding, TODO: change to best
449 static int _tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
450 int flag, uint32_t hash)
452 struct list_struct rec;
457 /* check for it existing, on insert. */
458 if (flag == TDB_INSERT) {
459 if (tdb_exists_hash(tdb, key, hash)) {
460 tdb->ecode = TDB_ERR_EXISTS;
464 /* first try in-place update, on modify or replace. */
465 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
468 if (tdb->ecode == TDB_ERR_NOEXIST &&
469 flag == TDB_MODIFY) {
470 /* if the record doesn't exist and we are in TDB_MODIFY mode then
471 we should fail the store */
475 /* reset the error code potentially set by the tdb_update() */
476 tdb->ecode = TDB_SUCCESS;
478 /* delete any existing record - if it doesn't exist we don't
479 care. Doing this first reduces fragmentation, and avoids
480 coalescing with `allocated' block before it's updated. */
481 if (flag != TDB_INSERT)
482 tdb_delete_hash(tdb, key, hash);
484 /* Copy key+value *before* allocating free space in case malloc
485 fails and we are left with a dead spot in the tdb. */
487 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
488 tdb->ecode = TDB_ERR_OOM;
492 memcpy(p, key.dptr, key.dsize);
494 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
496 if (tdb->max_dead_records != 0) {
498 * Allow for some dead records per hash chain, look if we can
499 * find one that can hold the new record. We need enough space
500 * for key, data and tailer. If we find one, we don't have to
501 * consult the central freelist.
503 rec_ptr = tdb_find_dead(
505 key.dsize + dbuf.dsize + sizeof(tdb_off_t));
508 rec.key_len = key.dsize;
509 rec.data_len = dbuf.dsize;
510 rec.full_hash = hash;
511 rec.magic = TDB_MAGIC;
512 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
513 || tdb->methods->tdb_write(
514 tdb, rec_ptr + sizeof(rec),
515 p, key.dsize + dbuf.dsize) == -1) {
523 * We have to allocate some space from the freelist, so this means we
524 * have to lock it. Use the chance to purge all the DEAD records from
525 * the hash chain under the freelist lock.
528 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
532 if ((tdb->max_dead_records != 0)
533 && (tdb_purge_dead(tdb, hash) == -1)) {
534 tdb_unlock(tdb, -1, F_WRLCK);
538 /* we have to allocate some space */
539 rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
541 tdb_unlock(tdb, -1, F_WRLCK);
547 /* Read hash top into next ptr */
548 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
551 rec.key_len = key.dsize;
552 rec.data_len = dbuf.dsize;
553 rec.full_hash = hash;
554 rec.magic = TDB_MAGIC;
556 /* write out and point the top of the hash chain at it */
557 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
558 || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
559 || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
560 /* Need to tdb_unallocate() here */
568 tdb_increment_seqnum(tdb);
575 /* store an element in the database, replacing any existing element
578 return 0 on success, -1 on failure
580 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
585 if (tdb->read_only || tdb->traverse_read) {
586 tdb->ecode = TDB_ERR_RDONLY;
587 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag,
592 /* find which hash bucket it is in */
593 hash = tdb->hash_fn(&key);
594 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
597 ret = _tdb_store(tdb, key, dbuf, flag, hash);
598 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag, ret);
599 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
604 /* Append to an entry. Create if not exist. */
605 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
611 /* find which hash bucket it is in */
612 hash = tdb->hash_fn(&key);
613 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
616 dbuf = do_tdb_fetch(tdb, key);
618 if (dbuf.dptr == NULL) {
619 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
621 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
622 unsigned char *new_dptr;
624 /* realloc '0' is special: don't do that. */
627 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
628 if (new_dptr == NULL) {
631 dbuf.dptr = new_dptr;
634 if (dbuf.dptr == NULL) {
635 tdb->ecode = TDB_ERR_OOM;
639 memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
640 dbuf.dsize += new_dbuf.dsize;
642 ret = _tdb_store(tdb, key, dbuf, 0, hash);
643 tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
646 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
647 SAFE_FREE(dbuf.dptr);
653 return the name of the current tdb file
654 useful for external logging functions
656 const char *tdb_name(struct tdb_context *tdb)
662 return the underlying file descriptor being used by tdb, or -1
663 useful for external routines that want to check the device/inode
666 int tdb_fd(struct tdb_context *tdb)
672 return the current logging function
673 useful for external tdb routines that wish to log tdb errors
675 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
677 return tdb->log.log_fn;
682 get the tdb sequence number. Only makes sense if the writers opened
683 with TDB_SEQNUM set. Note that this sequence number will wrap quite
684 quickly, so it should only be used for a 'has something changed'
685 test, not for code that relies on the count of the number of changes
686 made. If you want a counter then use a tdb record.
688 The aim of this sequence number is to allow for a very lightweight
689 test of a possible tdb change.
691 int tdb_get_seqnum(struct tdb_context *tdb)
695 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
696 tdb_trace_ret(tdb, "tdb_get_seqnum", seqnum);
700 int tdb_hash_size(struct tdb_context *tdb)
702 return tdb->header.hash_size;
705 size_t tdb_map_size(struct tdb_context *tdb)
707 return tdb->map_size;
710 int tdb_get_flags(struct tdb_context *tdb)
715 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
720 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
722 tdb->flags &= ~flags;
727 enable sequence number handling on an open tdb
729 void tdb_enable_seqnum(struct tdb_context *tdb)
731 tdb->flags |= TDB_SEQNUM;
736 add a region of the file to the freelist. Length is the size of the region in bytes,
737 which includes the free list header that needs to be added
739 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
741 struct list_struct rec;
742 if (length <= sizeof(rec)) {
743 /* the region is not worth adding */
746 if (length + offset > tdb->map_size) {
747 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
750 memset(&rec,'\0',sizeof(rec));
751 rec.rec_len = length - sizeof(rec);
752 if (tdb_free(tdb, offset, &rec) == -1) {
753 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
760 wipe the entire database, deleting all records. This can be done
761 very fast by using a global lock. The entire data portion of the
762 file becomes a single entry in the freelist.
764 This code carefully steps around the recovery area, leaving it alone
766 int tdb_wipe_all(struct tdb_context *tdb)
769 tdb_off_t offset = 0;
771 tdb_off_t recovery_head;
772 tdb_len_t recovery_size = 0;
774 if (tdb_lockall(tdb) != 0) {
778 tdb_trace(tdb, "tdb_wipe_all");
780 /* see if the tdb has a recovery area, and remember its size
781 if so. We don't want to lose this as otherwise each
782 tdb_wipe_all() in a transaction will increase the size of
783 the tdb by the size of the recovery area */
784 if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
785 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
789 if (recovery_head != 0) {
790 struct list_struct rec;
791 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
792 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
795 recovery_size = rec.rec_len + sizeof(rec);
798 /* wipe the hashes */
799 for (i=0;i<tdb->header.hash_size;i++) {
800 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
801 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
806 /* wipe the freelist */
807 if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
808 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
812 /* add all the rest of the file to the freelist, possibly leaving a gap
813 for the recovery area */
814 if (recovery_size == 0) {
815 /* the simple case - the whole file can be used as a freelist */
816 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
817 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
821 /* we need to add two freelist entries - one on either
822 side of the recovery area
824 Note that we cannot shift the recovery area during
825 this operation. Only the transaction.c code may
826 move the recovery area or we risk subtle data
829 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
830 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
833 /* and the 2nd free list entry after the recovery area - if any */
834 data_len = tdb->map_size - (recovery_head+recovery_size);
835 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
840 if (tdb_unlockall(tdb) != 0) {
841 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
853 struct traverse_state {
855 struct tdb_context *dest_db;
859 traverse function for repacking
861 static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private)
863 struct traverse_state *state = (struct traverse_state *)private;
864 if (tdb_store(state->dest_db, key, data, TDB_INSERT) != 0) {
874 int tdb_repack(struct tdb_context *tdb)
876 struct tdb_context *tmp_db;
877 struct traverse_state state;
879 tdb_trace(tdb, "tdb_repack");
881 if (tdb_transaction_start(tdb) != 0) {
882 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to start transaction\n"));
886 tmp_db = tdb_open("tmpdb", tdb_hash_size(tdb), TDB_INTERNAL, O_RDWR|O_CREAT, 0);
887 if (tmp_db == NULL) {
888 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to create tmp_db\n"));
889 tdb_transaction_cancel(tdb);
894 state.dest_db = tmp_db;
896 if (tdb_traverse_read(tdb, repack_traverse, &state) == -1) {
897 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying out\n"));
898 tdb_transaction_cancel(tdb);
904 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during traversal\n"));
905 tdb_transaction_cancel(tdb);
910 if (tdb_wipe_all(tdb) != 0) {
911 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to wipe database\n"));
912 tdb_transaction_cancel(tdb);
920 if (tdb_traverse_read(tmp_db, repack_traverse, &state) == -1) {
921 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying back\n"));
922 tdb_transaction_cancel(tdb);
928 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during second traversal\n"));
929 tdb_transaction_cancel(tdb);
936 if (tdb_transaction_commit(tdb) != 0) {
937 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to commit\n"));
945 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
947 if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
953 static void tdb_trace_start(struct tdb_context *tdb)
956 char msg[sizeof(tdb_off_t) * 4];
958 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
959 sprintf(msg, "%u ", seqnum);
960 tdb_trace_write(tdb, msg);
963 static void tdb_trace_end(struct tdb_context *tdb)
965 tdb_trace_write(tdb, "\n");
968 static void tdb_trace_end_ret(struct tdb_context *tdb, int ret)
970 char msg[sizeof(ret) * 4];
971 sprintf(msg, " = %i\n", ret);
972 tdb_trace_write(tdb, msg);
975 static void tdb_trace_record(struct tdb_context *tdb, TDB_DATA rec)
977 char msg[20 + rec.dsize*2], *p;
980 /* We differentiate zero-length records from non-existent ones. */
981 if (rec.dptr == NULL) {
982 tdb_trace_write(tdb, " NULL");
987 p += sprintf(p, " %zu:", rec.dsize);
988 for (i = 0; i < rec.dsize; i++)
989 p += sprintf(p, "%02x", rec.dptr[i]);
991 tdb_trace_write(tdb, msg);
994 void tdb_trace(struct tdb_context *tdb, const char *op)
996 tdb_trace_start(tdb);
997 tdb_trace_write(tdb, op);
1001 void tdb_trace_seqnum(struct tdb_context *tdb, uint32_t seqnum, const char *op)
1003 char msg[sizeof(tdb_off_t) * 4];
1005 sprintf(msg, "%u ", seqnum);
1006 tdb_trace_write(tdb, msg);
1007 tdb_trace_write(tdb, op);
1011 void tdb_trace_open(struct tdb_context *tdb, const char *op,
1012 unsigned hash_size, unsigned tdb_flags, unsigned open_flags)
1016 sprintf(msg, "%s %u %#x %#x", op, hash_size, tdb_flags, open_flags);
1017 tdb_trace_start(tdb);
1018 tdb_trace_write(tdb, msg);
1022 void tdb_trace_ret(struct tdb_context *tdb, const char *op, int ret)
1024 tdb_trace_start(tdb);
1025 tdb_trace_write(tdb, op);
1026 tdb_trace_end_ret(tdb, ret);
1029 void tdb_trace_retrec(struct tdb_context *tdb, const char *op, TDB_DATA ret)
1031 tdb_trace_start(tdb);
1032 tdb_trace_write(tdb, op);
1033 tdb_trace_write(tdb, " =");
1034 tdb_trace_record(tdb, ret);
1038 void tdb_trace_1rec(struct tdb_context *tdb, const char *op,
1041 tdb_trace_start(tdb);
1042 tdb_trace_write(tdb, op);
1043 tdb_trace_record(tdb, rec);
1047 void tdb_trace_1rec_ret(struct tdb_context *tdb, const char *op,
1048 TDB_DATA rec, int ret)
1050 tdb_trace_start(tdb);
1051 tdb_trace_write(tdb, op);
1052 tdb_trace_record(tdb, rec);
1053 tdb_trace_end_ret(tdb, ret);
1056 void tdb_trace_1rec_retrec(struct tdb_context *tdb, const char *op,
1057 TDB_DATA rec, TDB_DATA ret)
1059 tdb_trace_start(tdb);
1060 tdb_trace_write(tdb, op);
1061 tdb_trace_record(tdb, rec);
1062 tdb_trace_write(tdb, " =");
1063 tdb_trace_record(tdb, ret);
1067 void tdb_trace_2rec_flag_ret(struct tdb_context *tdb, const char *op,
1068 TDB_DATA rec1, TDB_DATA rec2, unsigned flag,
1071 char msg[sizeof(ret) * 4];
1073 sprintf(msg, " %#x", flag);
1074 tdb_trace_start(tdb);
1075 tdb_trace_write(tdb, op);
1076 tdb_trace_record(tdb, rec1);
1077 tdb_trace_record(tdb, rec2);
1078 tdb_trace_write(tdb, msg);
1079 tdb_trace_end_ret(tdb, ret);
1082 void tdb_trace_2rec_retrec(struct tdb_context *tdb, const char *op,
1083 TDB_DATA rec1, TDB_DATA rec2, TDB_DATA ret)
1085 tdb_trace_start(tdb);
1086 tdb_trace_write(tdb, op);
1087 tdb_trace_record(tdb, rec1);
1088 tdb_trace_record(tdb, rec2);
1089 tdb_trace_write(tdb, " =");
1090 tdb_trace_record(tdb, ret);