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"
32 non-blocking increment of the tdb sequence number if the tdb has been opened using
35 void tdb1_increment_seqnum_nonblock(struct tdb_context
*tdb
)
39 if (!(tdb
->flags
& TDB_SEQNUM
)) {
43 /* we ignore errors from this, as we have no sane way of
46 tdb1_ofs_read(tdb
, TDB1_SEQNUM_OFS
, &seqnum
);
48 tdb1_ofs_write(tdb
, TDB1_SEQNUM_OFS
, &seqnum
);
52 increment the tdb sequence number if the tdb has been opened using
55 static void tdb1_increment_seqnum(struct tdb_context
*tdb
)
57 if (!(tdb
->flags
& TDB_SEQNUM
)) {
61 if (tdb1_nest_lock(tdb
, TDB1_SEQNUM_OFS
, F_WRLCK
,
62 TDB_LOCK_WAIT
|TDB_LOCK_PROBE
) != 0) {
66 tdb1_increment_seqnum_nonblock(tdb
);
68 tdb1_nest_unlock(tdb
, TDB1_SEQNUM_OFS
, F_WRLCK
);
71 static enum TDB_ERROR
tdb1_key_compare(TDB_DATA key
, TDB_DATA data
,
74 bool *matches
= matches_
;
75 *matches
= (memcmp(data
.dptr
, key
.dptr
, data
.dsize
) == 0);
79 /* Returns 0 on fail; last_error will be TDB_ERR_NOEXIST if it simply
80 * wasn't there, otherwise a real error.
81 * On success, return offset of record, and fills in rec */
82 static tdb1_off_t
tdb1_find(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
,
83 struct tdb1_record
*r
)
87 /* read in the hash top */
88 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(hash
), &rec_ptr
) == -1)
91 /* keep looking until we find the right record */
93 if (tdb1_rec_read(tdb
, rec_ptr
, r
) == -1)
96 tdb
->stats
.compares
++;
98 tdb
->stats
.compare_wrong_bucket
++;
99 } else if (key
.dsize
!= r
->key_len
) {
100 tdb
->stats
.compare_wrong_keylen
++;
101 } else if (hash
!= r
->full_hash
) {
102 tdb
->stats
.compare_wrong_rechash
++;
104 enum TDB_ERROR ecode
;
106 ecode
= tdb1_parse_data(tdb
, key
, rec_ptr
+ sizeof(*r
),
107 r
->key_len
, tdb1_key_compare
,
110 if (ecode
!= TDB_SUCCESS
) {
111 tdb
->last_error
= ecode
;
116 tdb
->stats
.compare_wrong_keycmp
++;
121 /* detect tight infinite loop */
122 if (rec_ptr
== r
->next
) {
123 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_CORRUPT
,
125 "tdb1_find: loop detected.");
130 tdb
->last_error
= TDB_ERR_NOEXIST
;
134 /* As tdb1_find, but if you succeed, keep the lock */
135 tdb1_off_t
tdb1_find_lock_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
, int locktype
,
136 struct tdb1_record
*rec
)
140 if (tdb1_lock(tdb
, TDB1_BUCKET(hash
), locktype
) == -1)
142 if (!(rec_ptr
= tdb1_find(tdb
, key
, hash
, rec
)))
143 tdb1_unlock(tdb
, TDB1_BUCKET(hash
), locktype
);
147 static TDB_DATA
_tdb1_fetch(struct tdb_context
*tdb
, TDB_DATA key
);
149 /* update an entry in place - this only works if the new data size
150 is <= the old data size and the key exists.
151 on failure return -1.
153 static int tdb1_update_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
, TDB_DATA dbuf
)
155 struct tdb1_record rec
;
159 if (!(rec_ptr
= tdb1_find(tdb
, key
, hash
, &rec
)))
162 /* it could be an exact duplicate of what is there - this is
163 * surprisingly common (eg. with a ldb re-index). */
164 if (rec
.key_len
== key
.dsize
&&
165 rec
.data_len
== dbuf
.dsize
&&
166 rec
.full_hash
== hash
) {
167 TDB_DATA data
= _tdb1_fetch(tdb
, key
);
168 if (data
.dsize
== dbuf
.dsize
&&
169 memcmp(data
.dptr
, dbuf
.dptr
, data
.dsize
) == 0) {
180 /* must be long enough key, data and tailer */
181 if (rec
.rec_len
< key
.dsize
+ dbuf
.dsize
+ sizeof(tdb1_off_t
)) {
182 tdb
->last_error
= TDB_SUCCESS
; /* Not really an error */
186 if (tdb
->tdb1
.io
->tdb1_write(tdb
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
187 dbuf
.dptr
, dbuf
.dsize
) == -1)
190 if (dbuf
.dsize
!= rec
.data_len
) {
192 rec
.data_len
= dbuf
.dsize
;
193 return tdb1_rec_write(tdb
, rec_ptr
, &rec
);
199 /* find an entry in the database given a key */
200 /* If an entry doesn't exist tdb1_err will be set to
201 * TDB_ERR_NOEXIST. If a key has no data attached
202 * then the TDB_DATA will have zero length but
205 static TDB_DATA
_tdb1_fetch(struct tdb_context
*tdb
, TDB_DATA key
)
208 struct tdb1_record rec
;
212 /* find which hash bucket it is in */
213 hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
214 if (!(rec_ptr
= tdb1_find_lock_hash(tdb
,key
,hash
,F_RDLCK
,&rec
))) {
220 ret
.dptr
= tdb1_alloc_read(tdb
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
222 ret
.dsize
= rec
.data_len
;
223 tdb1_unlock(tdb
, TDB1_BUCKET(rec
.full_hash
), F_RDLCK
);
227 enum TDB_ERROR
tdb1_fetch(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA
*data
)
229 *data
= _tdb1_fetch(tdb
, key
);
230 if (data
->dptr
== NULL
)
231 return tdb
->last_error
;
235 enum TDB_ERROR
tdb1_parse_record(struct tdb_context
*tdb
, TDB_DATA key
,
236 enum TDB_ERROR (*parser
)(TDB_DATA key
,
242 struct tdb1_record rec
;
246 /* find which hash bucket it is in */
247 hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
249 if (!(rec_ptr
= tdb1_find_lock_hash(tdb
,key
,hash
,F_RDLCK
,&rec
))) {
250 return tdb
->last_error
;
253 ret
= tdb1_parse_data(tdb
, key
, rec_ptr
+ sizeof(rec
) + rec
.key_len
,
254 rec
.data_len
, parser
, private_data
);
256 tdb1_unlock(tdb
, TDB1_BUCKET(rec
.full_hash
), F_RDLCK
);
261 /* check if an entry in the database exists
263 note that 1 is returned if the key is found and 0 is returned if not found
264 this doesn't match the conventions in the rest of this module, but is
267 static int tdb1_exists_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
)
269 struct tdb1_record rec
;
271 if (tdb1_find_lock_hash(tdb
, key
, hash
, F_RDLCK
, &rec
) == 0)
273 tdb1_unlock(tdb
, TDB1_BUCKET(rec
.full_hash
), F_RDLCK
);
277 int tdb1_exists(struct tdb_context
*tdb
, TDB_DATA key
)
279 uint32_t hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
282 assert(tdb
->flags
& TDB_VERSION1
);
283 ret
= tdb1_exists_hash(tdb
, key
, hash
);
287 /* actually delete an entry in the database given the offset */
288 int tdb1_do_delete(struct tdb_context
*tdb
, tdb1_off_t rec_ptr
, struct tdb1_record
*rec
)
290 tdb1_off_t last_ptr
, i
;
291 struct tdb1_record lastrec
;
293 if ((tdb
->flags
& TDB_RDONLY
) || tdb
->tdb1
.traverse_read
) return -1;
295 if (((tdb
->tdb1
.traverse_write
!= 0) && (!TDB1_DEAD(rec
))) ||
296 tdb1_write_lock_record(tdb
, rec_ptr
) == -1) {
297 /* Someone traversing here: mark it as dead */
298 rec
->magic
= TDB1_DEAD_MAGIC
;
299 return tdb1_rec_write(tdb
, rec_ptr
, rec
);
301 if (tdb1_write_unlock_record(tdb
, rec_ptr
) != 0)
304 /* find previous record in hash chain */
305 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(rec
->full_hash
), &i
) == -1)
307 for (last_ptr
= 0; i
!= rec_ptr
; last_ptr
= i
, i
= lastrec
.next
)
308 if (tdb1_rec_read(tdb
, i
, &lastrec
) == -1)
311 /* unlink it: next ptr is at start of record. */
313 last_ptr
= TDB1_HASH_TOP(rec
->full_hash
);
314 if (tdb1_ofs_write(tdb
, last_ptr
, &rec
->next
) == -1)
317 /* recover the space */
318 if (tdb1_free(tdb
, rec_ptr
, rec
) == -1)
323 static int tdb1_count_dead(struct tdb_context
*tdb
, uint32_t hash
)
327 struct tdb1_record rec
;
329 /* read in the hash top */
330 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(hash
), &rec_ptr
) == -1)
334 if (tdb1_rec_read(tdb
, rec_ptr
, &rec
) == -1)
337 if (rec
.magic
== TDB1_DEAD_MAGIC
) {
346 * Purge all DEAD records from a hash chain
348 static int tdb1_purge_dead(struct tdb_context
*tdb
, uint32_t hash
)
351 struct tdb1_record rec
;
354 if (tdb1_lock(tdb
, -1, F_WRLCK
) == -1) {
358 /* read in the hash top */
359 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(hash
), &rec_ptr
) == -1)
365 if (tdb1_rec_read(tdb
, rec_ptr
, &rec
) == -1) {
371 if (rec
.magic
== TDB1_DEAD_MAGIC
372 && tdb1_do_delete(tdb
, rec_ptr
, &rec
) == -1) {
379 tdb1_unlock(tdb
, -1, F_WRLCK
);
383 /* delete an entry in the database given a key */
384 static int tdb1_delete_hash(struct tdb_context
*tdb
, TDB_DATA key
, uint32_t hash
)
387 struct tdb1_record rec
;
390 if (tdb
->tdb1
.max_dead_records
!= 0) {
393 * Allow for some dead records per hash chain, mainly for
394 * tdb's with a very high create/delete rate like locking.tdb.
397 if (tdb1_lock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
) == -1)
400 if (tdb1_count_dead(tdb
, hash
) >= tdb
->tdb1
.max_dead_records
) {
402 * Don't let the per-chain freelist grow too large,
403 * delete all existing dead records
405 tdb1_purge_dead(tdb
, hash
);
408 if (!(rec_ptr
= tdb1_find(tdb
, key
, hash
, &rec
))) {
409 tdb1_unlock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
);
414 * Just mark the record as dead.
416 rec
.magic
= TDB1_DEAD_MAGIC
;
417 ret
= tdb1_rec_write(tdb
, rec_ptr
, &rec
);
420 if (!(rec_ptr
= tdb1_find_lock_hash(tdb
, key
, hash
, F_WRLCK
,
424 ret
= tdb1_do_delete(tdb
, rec_ptr
, &rec
);
428 tdb1_increment_seqnum(tdb
);
431 if (tdb1_unlock(tdb
, TDB1_BUCKET(rec
.full_hash
), F_WRLCK
) != 0)
432 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
433 "tdb1_delete: WARNING tdb1_unlock failed!");
437 int tdb1_delete(struct tdb_context
*tdb
, TDB_DATA key
)
439 uint32_t hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
442 assert(tdb
->flags
& TDB_VERSION1
);
443 ret
= tdb1_delete_hash(tdb
, key
, hash
);
448 * See if we have a dead record around with enough space
450 static tdb1_off_t
tdb1_find_dead(struct tdb_context
*tdb
, uint32_t hash
,
451 struct tdb1_record
*r
, tdb1_len_t length
)
455 /* read in the hash top */
456 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(hash
), &rec_ptr
) == -1)
459 /* keep looking until we find the right record */
461 if (tdb1_rec_read(tdb
, rec_ptr
, r
) == -1)
464 if (TDB1_DEAD(r
) && r
->rec_len
>= length
) {
466 * First fit for simple coding, TODO: change to best
476 static int _tdb1_store(struct tdb_context
*tdb
, TDB_DATA key
,
477 TDB_DATA dbuf
, int flag
, uint32_t hash
)
479 struct tdb1_record rec
;
484 /* check for it existing, on insert. */
485 if (flag
== TDB_INSERT
) {
486 if (tdb1_exists_hash(tdb
, key
, hash
)) {
487 tdb
->last_error
= TDB_ERR_EXISTS
;
490 if (tdb
->last_error
!= TDB_ERR_NOEXIST
) {
494 /* first try in-place update, on modify or replace. */
495 if (tdb1_update_hash(tdb
, key
, hash
, dbuf
) == 0) {
498 if (tdb
->last_error
!= TDB_SUCCESS
) {
499 if (tdb
->last_error
!= TDB_ERR_NOEXIST
) {
502 if (flag
== TDB_MODIFY
) {
503 /* if the record doesn't exist and we are in TDB1_MODIFY mode then
504 we should fail the store */
509 /* reset the error code potentially set by the tdb1_update() */
510 tdb
->last_error
= TDB_SUCCESS
;
512 /* delete any existing record - if it doesn't exist we don't
513 care. Doing this first reduces fragmentation, and avoids
514 coalescing with `allocated' block before it's updated. */
515 if (flag
!= TDB_INSERT
)
516 tdb1_delete_hash(tdb
, key
, hash
);
518 /* Copy key+value *before* allocating free space in case malloc
519 fails and we are left with a dead spot in the tdb. */
521 if (!(p
= (char *)malloc(key
.dsize
+ dbuf
.dsize
))) {
522 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_OOM
, TDB_LOG_ERROR
,
523 "tdb1_store: out of memory"
528 memcpy(p
, key
.dptr
, key
.dsize
);
530 memcpy(p
+key
.dsize
, dbuf
.dptr
, dbuf
.dsize
);
532 if (tdb
->tdb1
.max_dead_records
!= 0) {
534 * Allow for some dead records per hash chain, look if we can
535 * find one that can hold the new record. We need enough space
536 * for key, data and tailer. If we find one, we don't have to
537 * consult the central freelist.
539 rec_ptr
= tdb1_find_dead(
541 key
.dsize
+ dbuf
.dsize
+ sizeof(tdb1_off_t
));
544 rec
.key_len
= key
.dsize
;
545 rec
.data_len
= dbuf
.dsize
;
546 rec
.full_hash
= hash
;
547 rec
.magic
= TDB1_MAGIC
;
548 if (tdb1_rec_write(tdb
, rec_ptr
, &rec
) == -1
549 || tdb
->tdb1
.io
->tdb1_write(
550 tdb
, rec_ptr
+ sizeof(rec
),
551 p
, key
.dsize
+ dbuf
.dsize
) == -1) {
559 * We have to allocate some space from the freelist, so this means we
560 * have to lock it. Use the chance to purge all the DEAD records from
561 * the hash chain under the freelist lock.
564 if (tdb1_lock(tdb
, -1, F_WRLCK
) == -1) {
568 if ((tdb
->tdb1
.max_dead_records
!= 0)
569 && (tdb1_purge_dead(tdb
, hash
) == -1)) {
570 tdb1_unlock(tdb
, -1, F_WRLCK
);
574 /* we have to allocate some space */
575 rec_ptr
= tdb1_allocate(tdb
, key
.dsize
+ dbuf
.dsize
, &rec
);
577 tdb1_unlock(tdb
, -1, F_WRLCK
);
583 /* Read hash top into next ptr */
584 if (tdb1_ofs_read(tdb
, TDB1_HASH_TOP(hash
), &rec
.next
) == -1)
587 rec
.key_len
= key
.dsize
;
588 rec
.data_len
= dbuf
.dsize
;
589 rec
.full_hash
= hash
;
590 rec
.magic
= TDB1_MAGIC
;
592 /* write out and point the top of the hash chain at it */
593 if (tdb1_rec_write(tdb
, rec_ptr
, &rec
) == -1
594 || tdb
->tdb1
.io
->tdb1_write(tdb
, rec_ptr
+sizeof(rec
), p
, key
.dsize
+dbuf
.dsize
)==-1
595 || tdb1_ofs_write(tdb
, TDB1_HASH_TOP(hash
), &rec_ptr
) == -1) {
596 /* Need to tdb1_unallocate() here */
604 tdb1_increment_seqnum(tdb
);
611 /* store an element in the database, replacing any existing element
614 return 0 on success, -1 on failure
616 int tdb1_store(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA dbuf
, int flag
)
621 assert(tdb
->flags
& TDB_VERSION1
);
623 if ((tdb
->flags
& TDB_RDONLY
) || tdb
->tdb1
.traverse_read
) {
624 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_RDONLY
,
626 "tdb_store: read-only tdb");
630 /* find which hash bucket it is in */
631 hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
632 if (tdb1_lock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
) == -1)
635 ret
= _tdb1_store(tdb
, key
, dbuf
, flag
, hash
);
636 tdb1_unlock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
);
640 /* Append to an entry. Create if not exist. */
641 int tdb1_append(struct tdb_context
*tdb
, TDB_DATA key
, TDB_DATA new_dbuf
)
647 assert(tdb
->flags
& TDB_VERSION1
);
649 /* find which hash bucket it is in */
650 hash
= tdb_hash(tdb
, key
.dptr
, key
.dsize
);
651 if (tdb1_lock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
) == -1)
654 dbuf
= _tdb1_fetch(tdb
, key
);
656 if (dbuf
.dptr
== NULL
) {
657 dbuf
.dptr
= (unsigned char *)malloc(new_dbuf
.dsize
);
659 unsigned int new_len
= dbuf
.dsize
+ new_dbuf
.dsize
;
660 unsigned char *new_dptr
;
662 /* realloc '0' is special: don't do that. */
665 new_dptr
= (unsigned char *)realloc(dbuf
.dptr
, new_len
);
666 if (new_dptr
== NULL
) {
669 dbuf
.dptr
= new_dptr
;
672 if (dbuf
.dptr
== NULL
) {
673 tdb
->last_error
= TDB_ERR_OOM
;
677 memcpy(dbuf
.dptr
+ dbuf
.dsize
, new_dbuf
.dptr
, new_dbuf
.dsize
);
678 dbuf
.dsize
+= new_dbuf
.dsize
;
680 ret
= _tdb1_store(tdb
, key
, dbuf
, 0, hash
);
683 tdb1_unlock(tdb
, TDB1_BUCKET(hash
), F_WRLCK
);
684 SAFE_FREE(dbuf
.dptr
);
690 get the tdb sequence number. Only makes sense if the writers opened
691 with TDB1_SEQNUM set. Note that this sequence number will wrap quite
692 quickly, so it should only be used for a 'has something changed'
693 test, not for code that relies on the count of the number of changes
694 made. If you want a counter then use a tdb record.
696 The aim of this sequence number is to allow for a very lightweight
697 test of a possible tdb change.
699 int tdb1_get_seqnum(struct tdb_context
*tdb
)
703 tdb1_ofs_read(tdb
, TDB1_SEQNUM_OFS
, &seqnum
);
709 add a region of the file to the freelist. Length is the size of the region in bytes,
710 which includes the free list header that needs to be added
712 static int tdb1_free_region(struct tdb_context
*tdb
, tdb1_off_t offset
, ssize_t length
)
714 struct tdb1_record rec
;
715 if (length
<= sizeof(rec
)) {
716 /* the region is not worth adding */
719 if (length
+ offset
> tdb
->file
->map_size
) {
720 tdb
->last_error
= tdb_logerr(tdb
, TDB_ERR_CORRUPT
, TDB_LOG_ERROR
,
721 "tdb1_free_region: adding region beyond"
725 memset(&rec
,'\0',sizeof(rec
));
726 rec
.rec_len
= length
- sizeof(rec
);
727 if (tdb1_free(tdb
, offset
, &rec
) == -1) {
728 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
729 "tdb1_free_region: failed to add free record");
736 wipe the entire database, deleting all records. This can be done
737 very fast by using a allrecord lock. The entire data portion of the
738 file becomes a single entry in the freelist.
740 This code carefully steps around the recovery area, leaving it alone
742 int tdb1_wipe_all(struct tdb_context
*tdb
)
745 tdb1_off_t offset
= 0;
747 tdb1_off_t recovery_head
;
748 tdb1_len_t recovery_size
= 0;
750 if (tdb_lockall(tdb
) != TDB_SUCCESS
) {
755 /* see if the tdb has a recovery area, and remember its size
756 if so. We don't want to lose this as otherwise each
757 tdb1_wipe_all() in a transaction will increase the size of
758 the tdb by the size of the recovery area */
759 if (tdb1_ofs_read(tdb
, TDB1_RECOVERY_HEAD
, &recovery_head
) == -1) {
760 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
761 "tdb1_wipe_all: failed to read recovery head");
765 if (recovery_head
!= 0) {
766 struct tdb1_record rec
;
767 if (tdb
->tdb1
.io
->tdb1_read(tdb
, recovery_head
, &rec
, sizeof(rec
), TDB1_DOCONV()) == -1) {
768 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
769 "tdb1_wipe_all: failed to read recovery record");
772 recovery_size
= rec
.rec_len
+ sizeof(rec
);
775 /* wipe the hashes */
776 for (i
=0;i
<tdb
->tdb1
.header
.hash_size
;i
++) {
777 if (tdb1_ofs_write(tdb
, TDB1_HASH_TOP(i
), &offset
) == -1) {
778 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
779 "tdb1_wipe_all: failed to write hash %d", i
);
784 /* wipe the freelist */
785 if (tdb1_ofs_write(tdb
, TDB1_FREELIST_TOP
, &offset
) == -1) {
786 tdb_logerr(tdb
, tdb
->last_error
, TDB_LOG_ERROR
,
787 "tdb1_wipe_all: failed to write freelist");
791 /* add all the rest of the file to the freelist, possibly leaving a gap
792 for the recovery area */
793 if (recovery_size
== 0) {
794 /* the simple case - the whole file can be used as a freelist */
795 data_len
= (tdb
->file
->map_size
- TDB1_DATA_START(tdb
->tdb1
.header
.hash_size
));
796 if (tdb1_free_region(tdb
, TDB1_DATA_START(tdb
->tdb1
.header
.hash_size
), data_len
) != 0) {
800 /* we need to add two freelist entries - one on either
801 side of the recovery area
803 Note that we cannot shift the recovery area during
804 this operation. Only the transaction.c code may
805 move the recovery area or we risk subtle data
808 data_len
= (recovery_head
- TDB1_DATA_START(tdb
->tdb1
.header
.hash_size
));
809 if (tdb1_free_region(tdb
, TDB1_DATA_START(tdb
->tdb1
.header
.hash_size
), data_len
) != 0) {
812 /* and the 2nd free list entry after the recovery area - if any */
813 data_len
= tdb
->file
->map_size
- (recovery_head
+recovery_size
);
814 if (tdb1_free_region(tdb
, recovery_head
+recovery_size
, data_len
) != 0) {
819 tdb1_increment_seqnum_nonblock(tdb
);
828 /* Even on files, we can get partial writes due to signals. */
829 bool tdb1_write_all(int fd
, const void *buf
, size_t count
)
833 ret
= write(fd
, buf
, count
);
836 buf
= (const char *)buf
+ ret
;