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_LOG((tdb, TDB_DEBUG_FATAL, "tdb_find: loop detected.\n"));
102 return TDB_ERRCODE(TDB_ERR_CORRUPT, 0);
106 return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
109 /* As tdb_find, but if you succeed, keep the lock */
110 tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
111 struct list_struct *rec)
115 if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
117 if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
118 tdb_unlock(tdb, BUCKET(hash), locktype);
123 /* update an entry in place - this only works if the new data size
124 is <= the old data size and the key exists.
125 on failure return -1.
127 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
129 struct list_struct rec;
133 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
136 /* must be long enough key, data and tailer */
137 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
138 tdb->ecode = TDB_SUCCESS; /* Not really an error */
142 if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
143 dbuf.dptr, dbuf.dsize) == -1)
146 if (dbuf.dsize != rec.data_len) {
148 rec.data_len = dbuf.dsize;
149 return tdb_rec_write(tdb, rec_ptr, &rec);
155 /* find an entry in the database given a key */
156 /* If an entry doesn't exist tdb_err will be set to
157 * TDB_ERR_NOEXIST. If a key has no data attached
158 * then the TDB_DATA will have zero length but
161 static TDB_DATA do_tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
164 struct list_struct rec;
168 /* find which hash bucket it is in */
169 hash = tdb->hash_fn(&key);
170 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
173 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
175 ret.dsize = rec.data_len;
176 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
180 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
182 TDB_DATA ret = do_tdb_fetch(tdb, key);
184 tdb_trace_1rec_retrec(tdb, "tdb_fetch", key, ret);
189 * Find an entry in the database and hand the record's data to a parsing
190 * function. The parsing function is executed under the chain read lock, so it
191 * should be fast and should not block on other syscalls.
193 * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
195 * For mmapped tdb's that do not have a transaction open it points the parsing
196 * function directly at the mmap area, it avoids the malloc/memcpy in this
197 * case. If a transaction is open or no mmap is available, it has to do
198 * malloc/read/parse/free.
200 * This is interesting for all readers of potentially large data structures in
201 * the tdb records, ldb indexes being one example.
204 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
205 int (*parser)(TDB_DATA key, TDB_DATA data,
210 struct list_struct rec;
214 /* find which hash bucket it is in */
215 hash = tdb->hash_fn(&key);
217 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
218 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key,
220 return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
222 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
224 ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
225 rec.data_len, parser, private_data);
227 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
232 /* check if an entry in the database exists
234 note that 1 is returned if the key is found and 0 is returned if not found
235 this doesn't match the conventions in the rest of this module, but is
238 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
240 struct list_struct rec;
242 if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
244 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
248 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
250 uint32_t hash = tdb->hash_fn(&key);
253 ret = tdb_exists_hash(tdb, key, hash);
254 tdb_trace_1rec_ret(tdb, "tdb_exists", key, ret);
258 /* actually delete an entry in the database given the offset */
259 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
261 tdb_off_t last_ptr, i;
262 struct list_struct lastrec;
264 if (tdb->read_only || tdb->traverse_read) return -1;
266 if (tdb->traverse_write != 0 ||
267 tdb_write_lock_record(tdb, rec_ptr) == -1) {
268 /* Someone traversing here: mark it as dead */
269 rec->magic = TDB_DEAD_MAGIC;
270 return tdb_rec_write(tdb, rec_ptr, rec);
272 if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
275 /* find previous record in hash chain */
276 if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
278 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
279 if (tdb_rec_read(tdb, i, &lastrec) == -1)
282 /* unlink it: next ptr is at start of record. */
284 last_ptr = TDB_HASH_TOP(rec->full_hash);
285 if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
288 /* recover the space */
289 if (tdb_free(tdb, rec_ptr, rec) == -1)
294 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
298 struct list_struct rec;
300 /* read in the hash top */
301 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
305 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
308 if (rec.magic == TDB_DEAD_MAGIC) {
317 * Purge all DEAD records from a hash chain
319 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
322 struct list_struct rec;
325 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
329 /* read in the hash top */
330 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
336 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
342 if (rec.magic == TDB_DEAD_MAGIC
343 && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
350 tdb_unlock(tdb, -1, F_WRLCK);
354 /* delete an entry in the database given a key */
355 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
358 struct list_struct rec;
361 if (tdb->max_dead_records != 0) {
364 * Allow for some dead records per hash chain, mainly for
365 * tdb's with a very high create/delete rate like locking.tdb.
368 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
371 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
373 * Don't let the per-chain freelist grow too large,
374 * delete all existing dead records
376 tdb_purge_dead(tdb, hash);
379 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
380 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
385 * Just mark the record as dead.
387 rec.magic = TDB_DEAD_MAGIC;
388 ret = tdb_rec_write(tdb, rec_ptr, &rec);
391 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
395 ret = tdb_do_delete(tdb, rec_ptr, &rec);
399 tdb_increment_seqnum(tdb);
402 if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
403 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
407 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
409 uint32_t hash = tdb->hash_fn(&key);
412 ret = tdb_delete_hash(tdb, key, hash);
413 tdb_trace_1rec_ret(tdb, "tdb_delete", key, ret);
418 * See if we have a dead record around with enough space
420 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
421 struct list_struct *r, tdb_len_t length)
425 /* read in the hash top */
426 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
429 /* keep looking until we find the right record */
431 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
434 if (TDB_DEAD(r) && r->rec_len >= length) {
436 * First fit for simple coding, TODO: change to best
446 static int _tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
447 int flag, uint32_t hash)
449 struct list_struct rec;
454 /* check for it existing, on insert. */
455 if (flag == TDB_INSERT) {
456 if (tdb_exists_hash(tdb, key, hash)) {
457 tdb->ecode = TDB_ERR_EXISTS;
461 /* first try in-place update, on modify or replace. */
462 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
465 if (tdb->ecode == TDB_ERR_NOEXIST &&
466 flag == TDB_MODIFY) {
467 /* if the record doesn't exist and we are in TDB_MODIFY mode then
468 we should fail the store */
472 /* reset the error code potentially set by the tdb_update() */
473 tdb->ecode = TDB_SUCCESS;
475 /* delete any existing record - if it doesn't exist we don't
476 care. Doing this first reduces fragmentation, and avoids
477 coalescing with `allocated' block before it's updated. */
478 if (flag != TDB_INSERT)
479 tdb_delete_hash(tdb, key, hash);
481 /* Copy key+value *before* allocating free space in case malloc
482 fails and we are left with a dead spot in the tdb. */
484 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
485 tdb->ecode = TDB_ERR_OOM;
489 memcpy(p, key.dptr, key.dsize);
491 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
493 if (tdb->max_dead_records != 0) {
495 * Allow for some dead records per hash chain, look if we can
496 * find one that can hold the new record. We need enough space
497 * for key, data and tailer. If we find one, we don't have to
498 * consult the central freelist.
500 rec_ptr = tdb_find_dead(
502 key.dsize + dbuf.dsize + sizeof(tdb_off_t));
505 rec.key_len = key.dsize;
506 rec.data_len = dbuf.dsize;
507 rec.full_hash = hash;
508 rec.magic = TDB_MAGIC;
509 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
510 || tdb->methods->tdb_write(
511 tdb, rec_ptr + sizeof(rec),
512 p, key.dsize + dbuf.dsize) == -1) {
520 * We have to allocate some space from the freelist, so this means we
521 * have to lock it. Use the chance to purge all the DEAD records from
522 * the hash chain under the freelist lock.
525 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
529 if ((tdb->max_dead_records != 0)
530 && (tdb_purge_dead(tdb, hash) == -1)) {
531 tdb_unlock(tdb, -1, F_WRLCK);
535 /* we have to allocate some space */
536 rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
538 tdb_unlock(tdb, -1, F_WRLCK);
544 /* Read hash top into next ptr */
545 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
548 rec.key_len = key.dsize;
549 rec.data_len = dbuf.dsize;
550 rec.full_hash = hash;
551 rec.magic = TDB_MAGIC;
553 /* write out and point the top of the hash chain at it */
554 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
555 || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
556 || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
557 /* Need to tdb_unallocate() here */
565 tdb_increment_seqnum(tdb);
572 /* store an element in the database, replacing any existing element
575 return 0 on success, -1 on failure
577 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
582 if (tdb->read_only || tdb->traverse_read) {
583 tdb->ecode = TDB_ERR_RDONLY;
584 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag,
589 /* find which hash bucket it is in */
590 hash = tdb->hash_fn(&key);
591 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
594 ret = _tdb_store(tdb, key, dbuf, flag, hash);
595 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag, ret);
596 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
601 /* Append to an entry. Create if not exist. */
602 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
608 /* find which hash bucket it is in */
609 hash = tdb->hash_fn(&key);
610 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
613 dbuf = do_tdb_fetch(tdb, key);
615 if (dbuf.dptr == NULL) {
616 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
618 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
619 unsigned char *new_dptr;
621 /* realloc '0' is special: don't do that. */
624 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
625 if (new_dptr == NULL) {
628 dbuf.dptr = new_dptr;
631 if (dbuf.dptr == NULL) {
632 tdb->ecode = TDB_ERR_OOM;
636 memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
637 dbuf.dsize += new_dbuf.dsize;
639 ret = _tdb_store(tdb, key, dbuf, 0, hash);
640 tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
643 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
644 SAFE_FREE(dbuf.dptr);
650 return the name of the current tdb file
651 useful for external logging functions
653 const char *tdb_name(struct tdb_context *tdb)
659 return the underlying file descriptor being used by tdb, or -1
660 useful for external routines that want to check the device/inode
663 int tdb_fd(struct tdb_context *tdb)
669 return the current logging function
670 useful for external tdb routines that wish to log tdb errors
672 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
674 return tdb->log.log_fn;
679 get the tdb sequence number. Only makes sense if the writers opened
680 with TDB_SEQNUM set. Note that this sequence number will wrap quite
681 quickly, so it should only be used for a 'has something changed'
682 test, not for code that relies on the count of the number of changes
683 made. If you want a counter then use a tdb record.
685 The aim of this sequence number is to allow for a very lightweight
686 test of a possible tdb change.
688 int tdb_get_seqnum(struct tdb_context *tdb)
692 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
693 tdb_trace_ret(tdb, "tdb_get_seqnum", seqnum);
697 int tdb_hash_size(struct tdb_context *tdb)
699 return tdb->header.hash_size;
702 size_t tdb_map_size(struct tdb_context *tdb)
704 return tdb->map_size;
707 int tdb_get_flags(struct tdb_context *tdb)
712 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
717 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
719 tdb->flags &= ~flags;
724 enable sequence number handling on an open tdb
726 void tdb_enable_seqnum(struct tdb_context *tdb)
728 tdb->flags |= TDB_SEQNUM;
733 add a region of the file to the freelist. Length is the size of the region in bytes,
734 which includes the free list header that needs to be added
736 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
738 struct list_struct rec;
739 if (length <= sizeof(rec)) {
740 /* the region is not worth adding */
743 if (length + offset > tdb->map_size) {
744 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
747 memset(&rec,'\0',sizeof(rec));
748 rec.rec_len = length - sizeof(rec);
749 if (tdb_free(tdb, offset, &rec) == -1) {
750 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
757 wipe the entire database, deleting all records. This can be done
758 very fast by using a global lock. The entire data portion of the
759 file becomes a single entry in the freelist.
761 This code carefully steps around the recovery area, leaving it alone
763 int tdb_wipe_all(struct tdb_context *tdb)
766 tdb_off_t offset = 0;
768 tdb_off_t recovery_head;
769 tdb_len_t recovery_size = 0;
771 if (tdb_lockall(tdb) != 0) {
775 tdb_trace(tdb, "tdb_wipe_all");
777 /* see if the tdb has a recovery area, and remember its size
778 if so. We don't want to lose this as otherwise each
779 tdb_wipe_all() in a transaction will increase the size of
780 the tdb by the size of the recovery area */
781 if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
782 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
786 if (recovery_head != 0) {
787 struct list_struct rec;
788 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
789 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
792 recovery_size = rec.rec_len + sizeof(rec);
795 /* wipe the hashes */
796 for (i=0;i<tdb->header.hash_size;i++) {
797 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
798 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
803 /* wipe the freelist */
804 if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
805 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
809 /* add all the rest of the file to the freelist, possibly leaving a gap
810 for the recovery area */
811 if (recovery_size == 0) {
812 /* the simple case - the whole file can be used as a freelist */
813 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
814 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
818 /* we need to add two freelist entries - one on either
819 side of the recovery area
821 Note that we cannot shift the recovery area during
822 this operation. Only the transaction.c code may
823 move the recovery area or we risk subtle data
826 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
827 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
830 /* and the 2nd free list entry after the recovery area - if any */
831 data_len = tdb->map_size - (recovery_head+recovery_size);
832 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
837 if (tdb_unlockall(tdb) != 0) {
838 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
850 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
852 if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
858 static void tdb_trace_start(struct tdb_context *tdb)
861 char msg[sizeof(tdb_off_t) * 4];
863 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
864 sprintf(msg, "%u ", seqnum);
865 tdb_trace_write(tdb, msg);
868 static void tdb_trace_end(struct tdb_context *tdb)
870 tdb_trace_write(tdb, "\n");
873 static void tdb_trace_end_ret(struct tdb_context *tdb, int ret)
875 char msg[sizeof(ret) * 4];
876 sprintf(msg, " = %i\n", ret);
877 tdb_trace_write(tdb, msg);
880 static void tdb_trace_record(struct tdb_context *tdb, TDB_DATA rec)
882 char msg[20 + rec.dsize*2], *p;
885 /* We differentiate zero-length records from non-existent ones. */
886 if (rec.dptr == NULL) {
887 tdb_trace_write(tdb, " NULL");
892 p += sprintf(p, " %zu:", rec.dsize);
893 for (i = 0; i < rec.dsize; i++)
894 p += sprintf(p, "%02x", rec.dptr[i]);
896 tdb_trace_write(tdb, msg);
899 void tdb_trace(struct tdb_context *tdb, const char *op)
901 tdb_trace_start(tdb);
902 tdb_trace_write(tdb, op);
906 void tdb_trace_seqnum(struct tdb_context *tdb, uint32_t seqnum, const char *op)
908 char msg[sizeof(tdb_off_t) * 4];
910 sprintf(msg, "%u ", seqnum);
911 tdb_trace_write(tdb, msg);
912 tdb_trace_write(tdb, op);
916 void tdb_trace_open(struct tdb_context *tdb, const char *op,
917 unsigned hash_size, unsigned tdb_flags, unsigned open_flags)
921 sprintf(msg, "%s %u %#x %#x", op, hash_size, tdb_flags, open_flags);
922 tdb_trace_start(tdb);
923 tdb_trace_write(tdb, msg);
927 void tdb_trace_ret(struct tdb_context *tdb, const char *op, int ret)
929 tdb_trace_start(tdb);
930 tdb_trace_write(tdb, op);
931 tdb_trace_end_ret(tdb, ret);
934 void tdb_trace_retrec(struct tdb_context *tdb, const char *op, TDB_DATA ret)
936 tdb_trace_start(tdb);
937 tdb_trace_write(tdb, op);
938 tdb_trace_write(tdb, " =");
939 tdb_trace_record(tdb, ret);
943 void tdb_trace_1rec(struct tdb_context *tdb, const char *op,
946 tdb_trace_start(tdb);
947 tdb_trace_write(tdb, op);
948 tdb_trace_record(tdb, rec);
952 void tdb_trace_1rec_ret(struct tdb_context *tdb, const char *op,
953 TDB_DATA rec, int ret)
955 tdb_trace_start(tdb);
956 tdb_trace_write(tdb, op);
957 tdb_trace_record(tdb, rec);
958 tdb_trace_end_ret(tdb, ret);
961 void tdb_trace_1rec_retrec(struct tdb_context *tdb, const char *op,
962 TDB_DATA rec, TDB_DATA ret)
964 tdb_trace_start(tdb);
965 tdb_trace_write(tdb, op);
966 tdb_trace_record(tdb, rec);
967 tdb_trace_write(tdb, " =");
968 tdb_trace_record(tdb, ret);
972 void tdb_trace_2rec_flag_ret(struct tdb_context *tdb, const char *op,
973 TDB_DATA rec1, TDB_DATA rec2, unsigned flag,
976 char msg[sizeof(ret) * 4];
978 sprintf(msg, " %#x", flag);
979 tdb_trace_start(tdb);
980 tdb_trace_write(tdb, op);
981 tdb_trace_record(tdb, rec1);
982 tdb_trace_record(tdb, rec2);
983 tdb_trace_write(tdb, msg);
984 tdb_trace_end_ret(tdb, ret);
987 void tdb_trace_2rec_retrec(struct tdb_context *tdb, const char *op,
988 TDB_DATA rec1, TDB_DATA rec2, TDB_DATA ret)
990 tdb_trace_start(tdb);
991 tdb_trace_write(tdb, op);
992 tdb_trace_record(tdb, rec1);
993 tdb_trace_record(tdb, rec2);
994 tdb_trace_write(tdb, " =");
995 tdb_trace_record(tdb, ret);