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 "tdb1_private.h"
34 non-blocking increment of the tdb sequence number if the tdb has been opened using
37 void tdb1_increment_seqnum_nonblock(struct tdb_context *tdb)
41 if (!(tdb->flags & TDB_SEQNUM)) {
45 /* we ignore errors from this, as we have no sane way of
48 tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
50 tdb1_ofs_write(tdb, TDB1_SEQNUM_OFS, &seqnum);
54 increment the tdb sequence number if the tdb has been opened using
57 static void tdb1_increment_seqnum(struct tdb_context *tdb)
59 if (!(tdb->flags & TDB_SEQNUM)) {
63 if (tdb1_nest_lock(tdb, TDB1_SEQNUM_OFS, F_WRLCK,
64 TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
68 tdb1_increment_seqnum_nonblock(tdb);
70 tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
73 static int tdb1_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
75 return memcmp(data.dptr, key.dptr, data.dsize);
78 /* Returns 0 on fail. On success, return offset of record, and fills
80 static tdb1_off_t tdb1_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
81 struct tdb1_record *r)
85 /* read in the hash top */
86 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
89 /* keep looking until we find the right record */
91 if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
94 if (!TDB1_DEAD(r) && hash==r->full_hash
95 && key.dsize==r->key_len
96 && tdb1_parse_data(tdb, key, rec_ptr + sizeof(*r),
97 r->key_len, tdb1_key_compare,
101 /* detect tight infinite loop */
102 if (rec_ptr == r->next) {
103 tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
105 "tdb1_find: loop detected.");
110 tdb->last_error = TDB_ERR_NOEXIST;
114 /* As tdb1_find, but if you succeed, keep the lock */
115 tdb1_off_t tdb1_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
116 struct tdb1_record *rec)
120 if (tdb1_lock(tdb, TDB1_BUCKET(hash), locktype) == -1)
122 if (!(rec_ptr = tdb1_find(tdb, key, hash, rec)))
123 tdb1_unlock(tdb, TDB1_BUCKET(hash), locktype);
127 static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key);
129 /* update an entry in place - this only works if the new data size
130 is <= the old data size and the key exists.
131 on failure return -1.
133 static int tdb1_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
135 struct tdb1_record rec;
139 if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec)))
142 /* it could be an exact duplicate of what is there - this is
143 * surprisingly common (eg. with a ldb re-index). */
144 if (rec.key_len == key.dsize &&
145 rec.data_len == dbuf.dsize &&
146 rec.full_hash == hash) {
147 TDB_DATA data = _tdb1_fetch(tdb, key);
148 if (data.dsize == dbuf.dsize &&
149 memcmp(data.dptr, dbuf.dptr, data.dsize) == 0) {
160 /* must be long enough key, data and tailer */
161 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb1_off_t)) {
162 tdb->last_error = TDB_SUCCESS; /* Not really an error */
166 if (tdb->tdb1.io->tdb1_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
167 dbuf.dptr, dbuf.dsize) == -1)
170 if (dbuf.dsize != rec.data_len) {
172 rec.data_len = dbuf.dsize;
173 return tdb1_rec_write(tdb, rec_ptr, &rec);
179 /* find an entry in the database given a key */
180 /* If an entry doesn't exist tdb1_err will be set to
181 * TDB_ERR_NOEXIST. If a key has no data attached
182 * then the TDB_DATA will have zero length but
185 static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key)
188 struct tdb1_record rec;
192 /* find which hash bucket it is in */
193 hash = tdb_hash(tdb, key.dptr, key.dsize);
194 if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec)))
197 ret.dptr = tdb1_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
199 ret.dsize = rec.data_len;
200 tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
204 enum TDB_ERROR tdb1_fetch(struct tdb_context *tdb, TDB_DATA key, TDB_DATA *data)
206 *data = _tdb1_fetch(tdb, key);
207 if (data->dptr == NULL)
208 return tdb->last_error;
213 * Find an entry in the database and hand the record's data to a parsing
214 * function. The parsing function is executed under the chain read lock, so it
215 * should be fast and should not block on other syscalls.
217 * DON'T CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
219 * For mmapped tdb's that do not have a transaction open it points the parsing
220 * function directly at the mmap area, it avoids the malloc/memcpy in this
221 * case. If a transaction is open or no mmap is available, it has to do
222 * malloc/read/parse/free.
224 * This is interesting for all readers of potentially large data structures in
225 * the tdb records, ldb indexes being one example.
227 * Return -1 if the record was not found.
230 int tdb1_parse_record(struct tdb_context *tdb, TDB_DATA key,
231 int (*parser)(TDB_DATA key, TDB_DATA data,
236 struct tdb1_record rec;
240 /* find which hash bucket it is in */
241 hash = tdb_hash(tdb, key.dptr, key.dsize);
243 if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
244 /* record not found */
245 tdb->last_error = TDB_ERR_NOEXIST;
249 ret = tdb1_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
250 rec.data_len, parser, private_data);
252 tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
257 /* check if an entry in the database exists
259 note that 1 is returned if the key is found and 0 is returned if not found
260 this doesn't match the conventions in the rest of this module, but is
263 static int tdb1_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
265 struct tdb1_record rec;
267 if (tdb1_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
269 tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
273 int tdb1_exists(struct tdb_context *tdb, TDB_DATA key)
275 uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
278 ret = tdb1_exists_hash(tdb, key, hash);
282 /* actually delete an entry in the database given the offset */
283 int tdb1_do_delete(struct tdb_context *tdb, tdb1_off_t rec_ptr, struct tdb1_record *rec)
285 tdb1_off_t last_ptr, i;
286 struct tdb1_record lastrec;
288 if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) return -1;
290 if (((tdb->tdb1.traverse_write != 0) && (!TDB1_DEAD(rec))) ||
291 tdb1_write_lock_record(tdb, rec_ptr) == -1) {
292 /* Someone traversing here: mark it as dead */
293 rec->magic = TDB1_DEAD_MAGIC;
294 return tdb1_rec_write(tdb, rec_ptr, rec);
296 if (tdb1_write_unlock_record(tdb, rec_ptr) != 0)
299 /* find previous record in hash chain */
300 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(rec->full_hash), &i) == -1)
302 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
303 if (tdb1_rec_read(tdb, i, &lastrec) == -1)
306 /* unlink it: next ptr is at start of record. */
308 last_ptr = TDB1_HASH_TOP(rec->full_hash);
309 if (tdb1_ofs_write(tdb, last_ptr, &rec->next) == -1)
312 /* recover the space */
313 if (tdb1_free(tdb, rec_ptr, rec) == -1)
318 static int tdb1_count_dead(struct tdb_context *tdb, uint32_t hash)
322 struct tdb1_record rec;
324 /* read in the hash top */
325 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
329 if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1)
332 if (rec.magic == TDB1_DEAD_MAGIC) {
341 * Purge all DEAD records from a hash chain
343 static int tdb1_purge_dead(struct tdb_context *tdb, uint32_t hash)
346 struct tdb1_record rec;
349 if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
353 /* read in the hash top */
354 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
360 if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1) {
366 if (rec.magic == TDB1_DEAD_MAGIC
367 && tdb1_do_delete(tdb, rec_ptr, &rec) == -1) {
374 tdb1_unlock(tdb, -1, F_WRLCK);
378 /* delete an entry in the database given a key */
379 static int tdb1_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
382 struct tdb1_record rec;
385 if (tdb->tdb1.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 (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
395 if (tdb1_count_dead(tdb, hash) >= tdb->tdb1.max_dead_records) {
397 * Don't let the per-chain freelist grow too large,
398 * delete all existing dead records
400 tdb1_purge_dead(tdb, hash);
403 if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec))) {
404 tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
409 * Just mark the record as dead.
411 rec.magic = TDB1_DEAD_MAGIC;
412 ret = tdb1_rec_write(tdb, rec_ptr, &rec);
415 if (!(rec_ptr = tdb1_find_lock_hash(tdb, key, hash, F_WRLCK,
419 ret = tdb1_do_delete(tdb, rec_ptr, &rec);
423 tdb1_increment_seqnum(tdb);
426 if (tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_WRLCK) != 0)
427 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
428 "tdb1_delete: WARNING tdb1_unlock failed!");
432 int tdb1_delete(struct tdb_context *tdb, TDB_DATA key)
434 uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
437 assert(tdb->flags & TDB_VERSION1);
438 ret = tdb1_delete_hash(tdb, key, hash);
443 * See if we have a dead record around with enough space
445 static tdb1_off_t tdb1_find_dead(struct tdb_context *tdb, uint32_t hash,
446 struct tdb1_record *r, tdb1_len_t length)
450 /* read in the hash top */
451 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
454 /* keep looking until we find the right record */
456 if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
459 if (TDB1_DEAD(r) && r->rec_len >= length) {
461 * First fit for simple coding, TODO: change to best
471 static int _tdb1_store(struct tdb_context *tdb, TDB_DATA key,
472 TDB_DATA dbuf, int flag, uint32_t hash)
474 struct tdb1_record rec;
479 /* check for it existing, on insert. */
480 if (flag == TDB_INSERT) {
481 if (tdb1_exists_hash(tdb, key, hash)) {
482 tdb->last_error = TDB_ERR_EXISTS;
486 /* first try in-place update, on modify or replace. */
487 if (tdb1_update_hash(tdb, key, hash, dbuf) == 0) {
490 if (tdb->last_error == TDB_ERR_NOEXIST &&
491 flag == TDB_MODIFY) {
492 /* if the record doesn't exist and we are in TDB1_MODIFY mode then
493 we should fail the store */
497 /* reset the error code potentially set by the tdb1_update() */
498 tdb->last_error = TDB_SUCCESS;
500 /* delete any existing record - if it doesn't exist we don't
501 care. Doing this first reduces fragmentation, and avoids
502 coalescing with `allocated' block before it's updated. */
503 if (flag != TDB_INSERT)
504 tdb1_delete_hash(tdb, key, hash);
506 /* Copy key+value *before* allocating free space in case malloc
507 fails and we are left with a dead spot in the tdb. */
509 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
510 tdb->last_error = TDB_ERR_OOM;
514 memcpy(p, key.dptr, key.dsize);
516 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
518 if (tdb->tdb1.max_dead_records != 0) {
520 * Allow for some dead records per hash chain, look if we can
521 * find one that can hold the new record. We need enough space
522 * for key, data and tailer. If we find one, we don't have to
523 * consult the central freelist.
525 rec_ptr = tdb1_find_dead(
527 key.dsize + dbuf.dsize + sizeof(tdb1_off_t));
530 rec.key_len = key.dsize;
531 rec.data_len = dbuf.dsize;
532 rec.full_hash = hash;
533 rec.magic = TDB1_MAGIC;
534 if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
535 || tdb->tdb1.io->tdb1_write(
536 tdb, rec_ptr + sizeof(rec),
537 p, key.dsize + dbuf.dsize) == -1) {
545 * We have to allocate some space from the freelist, so this means we
546 * have to lock it. Use the chance to purge all the DEAD records from
547 * the hash chain under the freelist lock.
550 if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
554 if ((tdb->tdb1.max_dead_records != 0)
555 && (tdb1_purge_dead(tdb, hash) == -1)) {
556 tdb1_unlock(tdb, -1, F_WRLCK);
560 /* we have to allocate some space */
561 rec_ptr = tdb1_allocate(tdb, key.dsize + dbuf.dsize, &rec);
563 tdb1_unlock(tdb, -1, F_WRLCK);
569 /* Read hash top into next ptr */
570 if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec.next) == -1)
573 rec.key_len = key.dsize;
574 rec.data_len = dbuf.dsize;
575 rec.full_hash = hash;
576 rec.magic = TDB1_MAGIC;
578 /* write out and point the top of the hash chain at it */
579 if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
580 || tdb->tdb1.io->tdb1_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
581 || tdb1_ofs_write(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1) {
582 /* Need to tdb1_unallocate() here */
590 tdb1_increment_seqnum(tdb);
597 /* store an element in the database, replacing any existing element
600 return 0 on success, -1 on failure
602 int tdb1_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
607 assert(tdb->flags & TDB_VERSION1);
609 if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
610 tdb->last_error = TDB_ERR_RDONLY;
614 /* find which hash bucket it is in */
615 hash = tdb_hash(tdb, key.dptr, key.dsize);
616 if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
619 ret = _tdb1_store(tdb, key, dbuf, flag, hash);
620 tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
624 /* Append to an entry. Create if not exist. */
625 int tdb1_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
631 assert(tdb->flags & TDB_VERSION1);
633 /* find which hash bucket it is in */
634 hash = tdb_hash(tdb, key.dptr, key.dsize);
635 if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
638 dbuf = _tdb1_fetch(tdb, key);
640 if (dbuf.dptr == NULL) {
641 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
643 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
644 unsigned char *new_dptr;
646 /* realloc '0' is special: don't do that. */
649 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
650 if (new_dptr == NULL) {
653 dbuf.dptr = new_dptr;
656 if (dbuf.dptr == NULL) {
657 tdb->last_error = TDB_ERR_OOM;
661 memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
662 dbuf.dsize += new_dbuf.dsize;
664 ret = _tdb1_store(tdb, key, dbuf, 0, hash);
667 tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
668 SAFE_FREE(dbuf.dptr);
674 get the tdb sequence number. Only makes sense if the writers opened
675 with TDB1_SEQNUM set. Note that this sequence number will wrap quite
676 quickly, so it should only be used for a 'has something changed'
677 test, not for code that relies on the count of the number of changes
678 made. If you want a counter then use a tdb record.
680 The aim of this sequence number is to allow for a very lightweight
681 test of a possible tdb change.
683 int tdb1_get_seqnum(struct tdb_context *tdb)
687 tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
693 add a region of the file to the freelist. Length is the size of the region in bytes,
694 which includes the free list header that needs to be added
696 static int tdb1_free_region(struct tdb_context *tdb, tdb1_off_t offset, ssize_t length)
698 struct tdb1_record rec;
699 if (length <= sizeof(rec)) {
700 /* the region is not worth adding */
703 if (length + offset > tdb->file->map_size) {
704 tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
705 "tdb1_free_region: adding region beyond"
709 memset(&rec,'\0',sizeof(rec));
710 rec.rec_len = length - sizeof(rec);
711 if (tdb1_free(tdb, offset, &rec) == -1) {
712 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
713 "tdb1_free_region: failed to add free record");
720 wipe the entire database, deleting all records. This can be done
721 very fast by using a allrecord lock. The entire data portion of the
722 file becomes a single entry in the freelist.
724 This code carefully steps around the recovery area, leaving it alone
726 int tdb1_wipe_all(struct tdb_context *tdb)
729 tdb1_off_t offset = 0;
731 tdb1_off_t recovery_head;
732 tdb1_len_t recovery_size = 0;
734 if (tdb1_lockall(tdb) != 0) {
739 /* see if the tdb has a recovery area, and remember its size
740 if so. We don't want to lose this as otherwise each
741 tdb1_wipe_all() in a transaction will increase the size of
742 the tdb by the size of the recovery area */
743 if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
744 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
745 "tdb1_wipe_all: failed to read recovery head");
749 if (recovery_head != 0) {
750 struct tdb1_record rec;
751 if (tdb->tdb1.io->tdb1_read(tdb, recovery_head, &rec, sizeof(rec), TDB1_DOCONV()) == -1) {
752 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
753 "tdb1_wipe_all: failed to read recovery record");
756 recovery_size = rec.rec_len + sizeof(rec);
759 /* wipe the hashes */
760 for (i=0;i<tdb->tdb1.header.hash_size;i++) {
761 if (tdb1_ofs_write(tdb, TDB1_HASH_TOP(i), &offset) == -1) {
762 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
763 "tdb1_wipe_all: failed to write hash %d", i);
768 /* wipe the freelist */
769 if (tdb1_ofs_write(tdb, TDB1_FREELIST_TOP, &offset) == -1) {
770 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
771 "tdb1_wipe_all: failed to write freelist");
775 /* add all the rest of the file to the freelist, possibly leaving a gap
776 for the recovery area */
777 if (recovery_size == 0) {
778 /* the simple case - the whole file can be used as a freelist */
779 data_len = (tdb->file->map_size - TDB1_DATA_START(tdb->tdb1.header.hash_size));
780 if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
784 /* we need to add two freelist entries - one on either
785 side of the recovery area
787 Note that we cannot shift the recovery area during
788 this operation. Only the transaction.c code may
789 move the recovery area or we risk subtle data
792 data_len = (recovery_head - TDB1_DATA_START(tdb->tdb1.header.hash_size));
793 if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
796 /* and the 2nd free list entry after the recovery area - if any */
797 data_len = tdb->file->map_size - (recovery_head+recovery_size);
798 if (tdb1_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
803 if (tdb1_unlockall(tdb) != 0) {
804 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
805 "tdb1_wipe_all: failed to unlock");
816 struct traverse_state {
817 enum TDB_ERROR error;
818 struct tdb_context *dest_db;
822 traverse function for repacking
824 static int repack_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data, void *private_data)
826 struct traverse_state *state = (struct traverse_state *)private_data;
827 if (tdb1_store(state->dest_db, key, data, TDB_INSERT) != 0) {
828 state->error = state->dest_db->last_error;
837 int tdb1_repack(struct tdb_context *tdb)
839 struct tdb_context *tmp_db;
840 struct traverse_state state;
841 union tdb_attribute hsize;
843 hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
844 hsize.base.next = NULL;
845 hsize.tdb1_hashsize.hsize = tdb->tdb1.header.hash_size;
847 if (tdb1_transaction_start(tdb) != 0) {
848 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
849 __location__ " Failed to start transaction");
853 tmp_db = tdb_open("tmpdb", TDB_INTERNAL, O_RDWR|O_CREAT, 0, &hsize);
854 if (tmp_db == NULL) {
855 tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
856 __location__ " Failed to create tmp_db");
857 tdb1_transaction_cancel(tdb);
861 state.error = TDB_SUCCESS;
862 state.dest_db = tmp_db;
864 if (tdb1_traverse_read(tdb, repack_traverse, &state) == -1) {
865 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
866 __location__ " Failed to traverse copying out");
867 tdb1_transaction_cancel(tdb);
872 if (state.error != TDB_SUCCESS) {
873 tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
874 __location__ " Error during traversal");
875 tdb1_transaction_cancel(tdb);
880 if (tdb1_wipe_all(tdb) != 0) {
881 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
882 __location__ " Failed to wipe database\n");
883 tdb1_transaction_cancel(tdb);
888 state.error = TDB_SUCCESS;
891 if (tdb1_traverse_read(tmp_db, repack_traverse, &state) == -1) {
892 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
893 __location__ " Failed to traverse copying back");
894 tdb1_transaction_cancel(tdb);
900 tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
901 __location__ " Error during second traversal");
902 tdb1_transaction_cancel(tdb);
909 if (tdb1_transaction_commit(tdb) != 0) {
910 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
911 __location__ " Failed to commit");
918 /* Even on files, we can get partial writes due to signals. */
919 bool tdb1_write_all(int fd, const void *buf, size_t count)
923 ret = write(fd, buf, count);
926 buf = (const char *)buf + ret;