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,
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 /* update an entry in place - this only works if the new data size
128 is <= the old data size and the key exists.
129 on failure return -1.
131 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
133 struct tdb_record rec;
137 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
140 /* it could be an exact duplicate of what is there - this is
141 * surprisingly common (eg. with a ldb re-index). */
142 if (rec.key_len == key.dsize &&
143 rec.data_len == dbuf.dsize &&
144 rec.full_hash == hash) {
145 TDB_DATA data = _tdb_fetch(tdb, key);
146 if (data.dsize == dbuf.dsize &&
147 memcmp(data.dptr, dbuf.dptr, data.dsize) == 0) {
159 /* must be long enough key, data and tailer */
160 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
161 tdb->ecode = TDB_SUCCESS; /* Not really an error */
165 if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
166 dbuf.dptr, dbuf.dsize) == -1)
169 if (dbuf.dsize != rec.data_len) {
171 rec.data_len = dbuf.dsize;
172 return tdb_rec_write(tdb, rec_ptr, &rec);
178 /* find an entry in the database given a key */
179 /* If an entry doesn't exist tdb_err will be set to
180 * TDB_ERR_NOEXIST. If a key has no data attached
181 * then the TDB_DATA will have zero length but
184 static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
187 struct tdb_record rec;
191 /* find which hash bucket it is in */
192 hash = tdb->hash_fn(&key);
193 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
196 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
198 ret.dsize = rec.data_len;
199 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
203 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
205 TDB_DATA ret = _tdb_fetch(tdb, key);
207 tdb_trace_1rec_retrec(tdb, "tdb_fetch", key, ret);
212 * Find an entry in the database and hand the record's data to a parsing
213 * function. The parsing function is executed under the chain read lock, so it
214 * should be fast and should not block on other syscalls.
216 * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
218 * For mmapped tdb's that do not have a transaction open it points the parsing
219 * function directly at the mmap area, it avoids the malloc/memcpy in this
220 * case. If a transaction is open or no mmap is available, it has to do
221 * malloc/read/parse/free.
223 * This is interesting for all readers of potentially large data structures in
224 * the tdb records, ldb indexes being one example.
227 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
228 int (*parser)(TDB_DATA key, TDB_DATA data,
233 struct tdb_record rec;
237 /* find which hash bucket it is in */
238 hash = tdb->hash_fn(&key);
240 if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
241 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key,
243 tdb->ecode = TDB_ERR_NOEXIST;
246 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
248 ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
249 rec.data_len, parser, private_data);
251 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
256 /* check if an entry in the database exists
258 note that 1 is returned if the key is found and 0 is returned if not found
259 this doesn't match the conventions in the rest of this module, but is
262 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
264 struct tdb_record rec;
266 if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
268 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
272 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
274 uint32_t hash = tdb->hash_fn(&key);
277 ret = tdb_exists_hash(tdb, key, hash);
278 tdb_trace_1rec_ret(tdb, "tdb_exists", key, ret);
282 /* actually delete an entry in the database given the offset */
283 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct tdb_record *rec)
285 tdb_off_t last_ptr, i;
286 struct tdb_record lastrec;
288 if (tdb->read_only || tdb->traverse_read) return -1;
290 if (tdb->traverse_write != 0 ||
291 tdb_write_lock_record(tdb, rec_ptr) == -1) {
292 /* Someone traversing here: mark it as dead */
293 rec->magic = TDB_DEAD_MAGIC;
294 return tdb_rec_write(tdb, rec_ptr, rec);
296 if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
299 /* find previous record in hash chain */
300 if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
302 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
303 if (tdb_rec_read(tdb, i, &lastrec) == -1)
306 /* unlink it: next ptr is at start of record. */
308 last_ptr = TDB_HASH_TOP(rec->full_hash);
309 if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
312 /* recover the space */
313 if (tdb_free(tdb, rec_ptr, rec) == -1)
318 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
322 struct tdb_record rec;
324 /* read in the hash top */
325 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
329 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
332 if (rec.magic == TDB_DEAD_MAGIC) {
341 * Purge all DEAD records from a hash chain
343 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
346 struct tdb_record rec;
349 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
353 /* read in the hash top */
354 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
360 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
366 if (rec.magic == TDB_DEAD_MAGIC
367 && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
374 tdb_unlock(tdb, -1, F_WRLCK);
378 /* delete an entry in the database given a key */
379 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
382 struct tdb_record rec;
385 if (tdb->max_dead_records != 0) {
388 * Allow for some dead records per hash chain, mainly for
389 * tdb's with a very high create/delete rate like locking.tdb.
392 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
395 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
397 * Don't let the per-chain freelist grow too large,
398 * delete all existing dead records
400 tdb_purge_dead(tdb, hash);
403 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
404 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
409 * Just mark the record as dead.
411 rec.magic = TDB_DEAD_MAGIC;
412 ret = tdb_rec_write(tdb, rec_ptr, &rec);
415 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
419 ret = tdb_do_delete(tdb, rec_ptr, &rec);
423 tdb_increment_seqnum(tdb);
426 if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
427 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
431 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
433 uint32_t hash = tdb->hash_fn(&key);
436 ret = tdb_delete_hash(tdb, key, hash);
437 tdb_trace_1rec_ret(tdb, "tdb_delete", key, ret);
442 * See if we have a dead record around with enough space
444 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
445 struct tdb_record *r, tdb_len_t length)
449 /* read in the hash top */
450 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
453 /* keep looking until we find the right record */
455 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
458 if (TDB_DEAD(r) && r->rec_len >= length) {
460 * First fit for simple coding, TODO: change to best
470 static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
471 TDB_DATA dbuf, int flag, uint32_t hash)
473 struct tdb_record rec;
478 /* check for it existing, on insert. */
479 if (flag == TDB_INSERT) {
480 if (tdb_exists_hash(tdb, key, hash)) {
481 tdb->ecode = TDB_ERR_EXISTS;
485 /* first try in-place update, on modify or replace. */
486 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
489 if (tdb->ecode == TDB_ERR_NOEXIST &&
490 flag == TDB_MODIFY) {
491 /* if the record doesn't exist and we are in TDB_MODIFY mode then
492 we should fail the store */
496 /* reset the error code potentially set by the tdb_update() */
497 tdb->ecode = TDB_SUCCESS;
499 /* delete any existing record - if it doesn't exist we don't
500 care. Doing this first reduces fragmentation, and avoids
501 coalescing with `allocated' block before it's updated. */
502 if (flag != TDB_INSERT)
503 tdb_delete_hash(tdb, key, hash);
505 /* Copy key+value *before* allocating free space in case malloc
506 fails and we are left with a dead spot in the tdb. */
508 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
509 tdb->ecode = TDB_ERR_OOM;
513 memcpy(p, key.dptr, key.dsize);
515 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
517 if (tdb->max_dead_records != 0) {
519 * Allow for some dead records per hash chain, look if we can
520 * find one that can hold the new record. We need enough space
521 * for key, data and tailer. If we find one, we don't have to
522 * consult the central freelist.
524 rec_ptr = tdb_find_dead(
526 key.dsize + dbuf.dsize + sizeof(tdb_off_t));
529 rec.key_len = key.dsize;
530 rec.data_len = dbuf.dsize;
531 rec.full_hash = hash;
532 rec.magic = TDB_MAGIC;
533 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
534 || tdb->methods->tdb_write(
535 tdb, rec_ptr + sizeof(rec),
536 p, key.dsize + dbuf.dsize) == -1) {
544 * We have to allocate some space from the freelist, so this means we
545 * have to lock it. Use the chance to purge all the DEAD records from
546 * the hash chain under the freelist lock.
549 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
553 if ((tdb->max_dead_records != 0)
554 && (tdb_purge_dead(tdb, hash) == -1)) {
555 tdb_unlock(tdb, -1, F_WRLCK);
559 /* we have to allocate some space */
560 rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
562 tdb_unlock(tdb, -1, F_WRLCK);
568 /* Read hash top into next ptr */
569 if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
572 rec.key_len = key.dsize;
573 rec.data_len = dbuf.dsize;
574 rec.full_hash = hash;
575 rec.magic = TDB_MAGIC;
577 /* write out and point the top of the hash chain at it */
578 if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
579 || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
580 || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
581 /* Need to tdb_unallocate() here */
589 tdb_increment_seqnum(tdb);
596 /* store an element in the database, replacing any existing element
599 return 0 on success, -1 on failure
601 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
606 if (tdb->read_only || tdb->traverse_read) {
607 tdb->ecode = TDB_ERR_RDONLY;
608 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag,
613 /* find which hash bucket it is in */
614 hash = tdb->hash_fn(&key);
615 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
618 ret = _tdb_store(tdb, key, dbuf, flag, hash);
619 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag, ret);
620 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
625 /* Append to an entry. Create if not exist. */
626 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
632 /* find which hash bucket it is in */
633 hash = tdb->hash_fn(&key);
634 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
637 dbuf = _tdb_fetch(tdb, key);
639 if (dbuf.dptr == NULL) {
640 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
642 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
643 unsigned char *new_dptr;
645 /* realloc '0' is special: don't do that. */
648 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
649 if (new_dptr == NULL) {
652 dbuf.dptr = new_dptr;
655 if (dbuf.dptr == NULL) {
656 tdb->ecode = TDB_ERR_OOM;
660 memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
661 dbuf.dsize += new_dbuf.dsize;
663 ret = _tdb_store(tdb, key, dbuf, 0, hash);
664 tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
667 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
668 SAFE_FREE(dbuf.dptr);
674 return the name of the current tdb file
675 useful for external logging functions
677 const char *tdb_name(struct tdb_context *tdb)
683 return the underlying file descriptor being used by tdb, or -1
684 useful for external routines that want to check the device/inode
687 int tdb_fd(struct tdb_context *tdb)
693 return the current logging function
694 useful for external tdb routines that wish to log tdb errors
696 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
698 return tdb->log.log_fn;
703 get the tdb sequence number. Only makes sense if the writers opened
704 with TDB_SEQNUM set. Note that this sequence number will wrap quite
705 quickly, so it should only be used for a 'has something changed'
706 test, not for code that relies on the count of the number of changes
707 made. If you want a counter then use a tdb record.
709 The aim of this sequence number is to allow for a very lightweight
710 test of a possible tdb change.
712 int tdb_get_seqnum(struct tdb_context *tdb)
716 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
717 tdb_trace_ret(tdb, "tdb_get_seqnum", seqnum);
721 int tdb_hash_size(struct tdb_context *tdb)
723 return tdb->header.hash_size;
726 size_t tdb_map_size(struct tdb_context *tdb)
728 return tdb->map_size;
731 int tdb_get_flags(struct tdb_context *tdb)
736 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
738 if ((flags & TDB_ALLOW_NESTING) &&
739 (flags & TDB_DISALLOW_NESTING)) {
740 tdb->ecode = TDB_ERR_NESTING;
741 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_add_flags: "
742 "allow_nesting and disallow_nesting are not allowed together!"));
746 if (flags & TDB_ALLOW_NESTING) {
747 tdb->flags &= ~TDB_DISALLOW_NESTING;
749 if (flags & TDB_DISALLOW_NESTING) {
750 tdb->flags &= ~TDB_ALLOW_NESTING;
756 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
758 if ((flags & TDB_ALLOW_NESTING) &&
759 (flags & TDB_DISALLOW_NESTING)) {
760 tdb->ecode = TDB_ERR_NESTING;
761 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_remove_flags: "
762 "allow_nesting and disallow_nesting are not allowed together!"));
766 if (flags & TDB_ALLOW_NESTING) {
767 tdb->flags |= TDB_DISALLOW_NESTING;
769 if (flags & TDB_DISALLOW_NESTING) {
770 tdb->flags |= TDB_ALLOW_NESTING;
773 tdb->flags &= ~flags;
778 enable sequence number handling on an open tdb
780 void tdb_enable_seqnum(struct tdb_context *tdb)
782 tdb->flags |= TDB_SEQNUM;
787 add a region of the file to the freelist. Length is the size of the region in bytes,
788 which includes the free list header that needs to be added
790 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
792 struct tdb_record rec;
793 if (length <= sizeof(rec)) {
794 /* the region is not worth adding */
797 if (length + offset > tdb->map_size) {
798 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
801 memset(&rec,'\0',sizeof(rec));
802 rec.rec_len = length - sizeof(rec);
803 if (tdb_free(tdb, offset, &rec) == -1) {
804 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
811 wipe the entire database, deleting all records. This can be done
812 very fast by using a global lock. The entire data portion of the
813 file becomes a single entry in the freelist.
815 This code carefully steps around the recovery area, leaving it alone
817 int tdb_wipe_all(struct tdb_context *tdb)
820 tdb_off_t offset = 0;
822 tdb_off_t recovery_head;
823 tdb_len_t recovery_size = 0;
825 if (tdb_lockall(tdb) != 0) {
829 tdb_trace(tdb, "tdb_wipe_all");
831 /* see if the tdb has a recovery area, and remember its size
832 if so. We don't want to lose this as otherwise each
833 tdb_wipe_all() in a transaction will increase the size of
834 the tdb by the size of the recovery area */
835 if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
836 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
840 if (recovery_head != 0) {
841 struct tdb_record rec;
842 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
843 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
846 recovery_size = rec.rec_len + sizeof(rec);
849 /* wipe the hashes */
850 for (i=0;i<tdb->header.hash_size;i++) {
851 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
852 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
857 /* wipe the freelist */
858 if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
859 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
863 /* add all the rest of the file to the freelist, possibly leaving a gap
864 for the recovery area */
865 if (recovery_size == 0) {
866 /* the simple case - the whole file can be used as a freelist */
867 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
868 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
872 /* we need to add two freelist entries - one on either
873 side of the recovery area
875 Note that we cannot shift the recovery area during
876 this operation. Only the transaction.c code may
877 move the recovery area or we risk subtle data
880 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
881 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
884 /* and the 2nd free list entry after the recovery area - if any */
885 data_len = tdb->map_size - (recovery_head+recovery_size);
886 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
891 if (tdb_unlockall(tdb) != 0) {
892 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
904 struct traverse_state {
906 struct tdb_context *dest_db;
910 traverse function for repacking
912 static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private)
914 struct traverse_state *state = (struct traverse_state *)private;
915 if (tdb_store(state->dest_db, key, data, TDB_INSERT) != 0) {
925 int tdb_repack(struct tdb_context *tdb)
927 struct tdb_context *tmp_db;
928 struct traverse_state state;
930 tdb_trace(tdb, "tdb_repack");
932 if (tdb_transaction_start(tdb) != 0) {
933 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to start transaction\n"));
937 tmp_db = tdb_open("tmpdb", tdb_hash_size(tdb), TDB_INTERNAL, O_RDWR|O_CREAT, 0);
938 if (tmp_db == NULL) {
939 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to create tmp_db\n"));
940 tdb_transaction_cancel(tdb);
945 state.dest_db = tmp_db;
947 if (tdb_traverse_read(tdb, repack_traverse, &state) == -1) {
948 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying out\n"));
949 tdb_transaction_cancel(tdb);
955 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during traversal\n"));
956 tdb_transaction_cancel(tdb);
961 if (tdb_wipe_all(tdb) != 0) {
962 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to wipe database\n"));
963 tdb_transaction_cancel(tdb);
971 if (tdb_traverse_read(tmp_db, repack_traverse, &state) == -1) {
972 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to traverse copying back\n"));
973 tdb_transaction_cancel(tdb);
979 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Error during second traversal\n"));
980 tdb_transaction_cancel(tdb);
987 if (tdb_transaction_commit(tdb) != 0) {
988 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_repack: Failed to commit\n"));
996 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
998 if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
1004 static void tdb_trace_start(struct tdb_context *tdb)
1007 char msg[sizeof(tdb_off_t) * 4];
1009 tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
1010 sprintf(msg, "%u ", seqnum);
1011 tdb_trace_write(tdb, msg);
1014 static void tdb_trace_end(struct tdb_context *tdb)
1016 tdb_trace_write(tdb, "\n");
1019 static void tdb_trace_end_ret(struct tdb_context *tdb, int ret)
1021 char msg[sizeof(ret) * 4];
1022 sprintf(msg, " = %i\n", ret);
1023 tdb_trace_write(tdb, msg);
1026 static void tdb_trace_record(struct tdb_context *tdb, TDB_DATA rec)
1028 char msg[20 + rec.dsize*2], *p;
1031 /* We differentiate zero-length records from non-existent ones. */
1032 if (rec.dptr == NULL) {
1033 tdb_trace_write(tdb, " NULL");
1038 p += sprintf(p, " %zu:", rec.dsize);
1039 for (i = 0; i < rec.dsize; i++)
1040 p += sprintf(p, "%02x", rec.dptr[i]);
1042 tdb_trace_write(tdb, msg);
1045 void tdb_trace(struct tdb_context *tdb, const char *op)
1047 tdb_trace_start(tdb);
1048 tdb_trace_write(tdb, op);
1052 void tdb_trace_seqnum(struct tdb_context *tdb, uint32_t seqnum, const char *op)
1054 char msg[sizeof(tdb_off_t) * 4];
1056 sprintf(msg, "%u ", seqnum);
1057 tdb_trace_write(tdb, msg);
1058 tdb_trace_write(tdb, op);
1062 void tdb_trace_open(struct tdb_context *tdb, const char *op,
1063 unsigned hash_size, unsigned tdb_flags, unsigned open_flags)
1067 sprintf(msg, "%s %u %#x %#x", op, hash_size, tdb_flags, open_flags);
1068 tdb_trace_start(tdb);
1069 tdb_trace_write(tdb, msg);
1073 void tdb_trace_ret(struct tdb_context *tdb, const char *op, int ret)
1075 tdb_trace_start(tdb);
1076 tdb_trace_write(tdb, op);
1077 tdb_trace_end_ret(tdb, ret);
1080 void tdb_trace_retrec(struct tdb_context *tdb, const char *op, TDB_DATA ret)
1082 tdb_trace_start(tdb);
1083 tdb_trace_write(tdb, op);
1084 tdb_trace_write(tdb, " =");
1085 tdb_trace_record(tdb, ret);
1089 void tdb_trace_1rec(struct tdb_context *tdb, const char *op,
1092 tdb_trace_start(tdb);
1093 tdb_trace_write(tdb, op);
1094 tdb_trace_record(tdb, rec);
1098 void tdb_trace_1rec_ret(struct tdb_context *tdb, const char *op,
1099 TDB_DATA rec, int ret)
1101 tdb_trace_start(tdb);
1102 tdb_trace_write(tdb, op);
1103 tdb_trace_record(tdb, rec);
1104 tdb_trace_end_ret(tdb, ret);
1107 void tdb_trace_1rec_retrec(struct tdb_context *tdb, const char *op,
1108 TDB_DATA rec, TDB_DATA ret)
1110 tdb_trace_start(tdb);
1111 tdb_trace_write(tdb, op);
1112 tdb_trace_record(tdb, rec);
1113 tdb_trace_write(tdb, " =");
1114 tdb_trace_record(tdb, ret);
1118 void tdb_trace_2rec_flag_ret(struct tdb_context *tdb, const char *op,
1119 TDB_DATA rec1, TDB_DATA rec2, unsigned flag,
1122 char msg[sizeof(ret) * 4];
1124 sprintf(msg, " %#x", flag);
1125 tdb_trace_start(tdb);
1126 tdb_trace_write(tdb, op);
1127 tdb_trace_record(tdb, rec1);
1128 tdb_trace_record(tdb, rec2);
1129 tdb_trace_write(tdb, msg);
1130 tdb_trace_end_ret(tdb, ret);
1133 void tdb_trace_2rec_retrec(struct tdb_context *tdb, const char *op,
1134 TDB_DATA rec1, TDB_DATA rec2, TDB_DATA ret)
1136 tdb_trace_start(tdb);
1137 tdb_trace_write(tdb, op);
1138 tdb_trace_record(tdb, rec1);
1139 tdb_trace_record(tdb, rec2);
1140 tdb_trace_write(tdb, " =");
1141 tdb_trace_record(tdb, ret);