#include "tdb1_private.h"
-/* 'right' merges can involve O(n^2) cost when combined with a
- traverse, so they are disabled until we find a way to do them in
- O(1) time
-*/
-#define USE_RIGHT_MERGES 0
-
/* read a freelist record and check for simple errors */
-int tdb1_rec_free_read(struct tdb1_context *tdb, tdb1_off_t off, struct tdb1_record *rec)
+int tdb1_rec_free_read(struct tdb_context *tdb, tdb1_off_t off, struct tdb1_record *rec)
{
- if (tdb->methods->tdb1_read(tdb, off, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
+ if (tdb->tdb1.io->tdb1_read(tdb, off, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
return -1;
if (rec->magic == TDB1_MAGIC) {
/* this happens when a app is showdown while deleting a record - we should
not completely fail when this happens */
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_rec_free_read non-free magic 0x%x at offset=%d - fixing\n",
- rec->magic, off));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_WARNING,
+ "tdb1_rec_free_read non-free magic 0x%x at offset=%d - fixing\n",
+ rec->magic, off);
rec->magic = TDB1_FREE_MAGIC;
- if (tdb->methods->tdb1_write(tdb, off, rec, sizeof(*rec)) == -1)
+ if (tdb->tdb1.io->tdb1_write(tdb, off, rec, sizeof(*rec)) == -1)
return -1;
}
if (rec->magic != TDB1_FREE_MAGIC) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_rec_free_read bad magic 0x%x at offset=%d\n",
- rec->magic, off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_rec_free_read bad magic 0x%x at offset=%d\n",
+ rec->magic, off);
return -1;
}
- if (tdb->methods->tdb1_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
+ if (tdb->tdb1.io->tdb1_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
return -1;
return 0;
}
-#if USE_RIGHT_MERGES
-/* Remove an element from the freelist. Must have alloc lock. */
-static int remove_from_freelist(struct tdb1_context *tdb, tdb1_off_t off, tdb1_off_t next)
-{
- tdb1_off_t last_ptr, i;
-
- /* read in the freelist top */
- last_ptr = TDB1_FREELIST_TOP;
- while (tdb1_ofs_read(tdb, last_ptr, &i) != -1 && i != 0) {
- if (i == off) {
- /* We've found it! */
- return tdb1_ofs_write(tdb, last_ptr, &next);
- }
- /* Follow chain (next offset is at start of record) */
- last_ptr = i;
- }
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"remove_from_freelist: not on list at off=%d\n", off));
- return -1;
-}
-#endif
-
-
/* update a record tailer (must hold allocation lock) */
-static int update_tailer(struct tdb1_context *tdb, tdb1_off_t offset,
+static int update_tailer(struct tdb_context *tdb, tdb1_off_t offset,
const struct tdb1_record *rec)
{
tdb1_off_t totalsize;
/* Add an element into the freelist. Merge adjacent records if
necessary. */
-int tdb1_free(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
+int tdb1_free(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
{
/* Allocation and tailer lock */
if (tdb1_lock(tdb, -1, F_WRLCK) != 0)
/* set an initial tailer, so if we fail we don't leave a bogus record */
if (update_tailer(tdb, offset, rec) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: update_tailer failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb_free: update_tailer failed!\n");
goto fail;
}
-#if USE_RIGHT_MERGES
- /* Look right first (I'm an Australian, dammit) */
- if (offset + sizeof(*rec) + rec->rec_len + sizeof(*rec) <= tdb->map_size) {
- tdb1_off_t right = offset + sizeof(*rec) + rec->rec_len;
- struct tdb1_record r;
-
- if (tdb->methods->tdb1_read(tdb, right, &r, sizeof(r), TDB1_DOCONV()) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: right read failed at %u\n", right));
- goto left;
- }
-
- /* If it's free, expand to include it. */
- if (r.magic == TDB1_FREE_MAGIC) {
- if (remove_from_freelist(tdb, right, r.next) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: right free failed at %u\n", right));
- goto left;
- }
- rec->rec_len += sizeof(r) + r.rec_len;
- if (update_tailer(tdb, offset, rec) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: update_tailer failed at %u\n", offset));
- goto fail;
- }
- }
- }
-left:
-#endif
-
+ tdb->stats.alloc_coalesce_tried++;
/* Look left */
- if (offset - sizeof(tdb1_off_t) > TDB1_DATA_START(tdb->header.hash_size)) {
+ if (offset - sizeof(tdb1_off_t) > TDB1_DATA_START(tdb->tdb1.header.hash_size)) {
tdb1_off_t left = offset - sizeof(tdb1_off_t);
struct tdb1_record l;
tdb1_off_t leftsize;
/* Read in tailer and jump back to header */
if (tdb1_ofs_read(tdb, left, &leftsize) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: left offset read failed at %u\n", left));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free: left offset read failed at %u", left);
goto update;
}
left = offset - leftsize;
if (leftsize > offset ||
- left < TDB1_DATA_START(tdb->header.hash_size)) {
+ left < TDB1_DATA_START(tdb->tdb1.header.hash_size)) {
goto update;
}
/* Now read in the left record */
- if (tdb->methods->tdb1_read(tdb, left, &l, sizeof(l), TDB1_DOCONV()) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: left read failed at %u (%u)\n", left, leftsize));
+ if (tdb->tdb1.io->tdb1_read(tdb, left, &l, sizeof(l), TDB1_DOCONV()) == -1) {
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free: left read failed at %u (%u)", left, leftsize);
goto update;
}
prevents traverse from being O(n^2) after a lot of deletes */
l.rec_len += sizeof(*rec) + rec->rec_len;
if (tdb1_rec_write(tdb, left, &l) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: update_left failed at %u\n", left));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free: update_left failed at %u", left);
goto fail;
}
if (update_tailer(tdb, left, &l) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free: update_tailer failed at %u\n", offset));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free: update_tailer failed at %u", offset);
goto fail;
}
+ tdb->stats.alloc_coalesce_succeeded++;
+ tdb->stats.alloc_coalesce_num_merged++;
+ tdb->stats.frees++;
tdb1_unlock(tdb, -1, F_WRLCK);
return 0;
}
if (tdb1_ofs_read(tdb, TDB1_FREELIST_TOP, &rec->next) == -1 ||
tdb1_rec_write(tdb, offset, rec) == -1 ||
tdb1_ofs_write(tdb, TDB1_FREELIST_TOP, &offset) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_free record write failed at offset=%d\n", offset));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free record write failed at offset=%d",
+ offset);
goto fail;
}
/* And we're done. */
+ tdb->stats.frees++;
tdb1_unlock(tdb, -1, F_WRLCK);
return 0;
not the beginning. This is so the left merge in a free is more likely to be
able to free up the record without fragmentation
*/
-static tdb1_off_t tdb1_allocate_ofs(struct tdb1_context *tdb,
+static tdb1_off_t tdb1_allocate_ofs(struct tdb_context *tdb,
tdb1_len_t length, tdb1_off_t rec_ptr,
struct tdb1_record *rec, tdb1_off_t last_ptr)
{
if (tdb1_rec_write(tdb, rec_ptr, rec) == -1) {
return 0;
}
+ tdb->stats.allocs++;
return rec_ptr;
}
return 0;
}
+ tdb->stats.allocs++;
+ tdb->stats.alloc_leftover++;
return rec_ptr;
}
0 is returned if the space could not be allocated
*/
-tdb1_off_t tdb1_allocate(struct tdb1_context *tdb, tdb1_len_t length, struct tdb1_record *rec)
+tdb1_off_t tdb1_allocate(struct tdb_context *tdb, tdb1_len_t length, struct tdb1_record *rec)
{
tdb1_off_t rec_ptr, last_ptr, newrec_ptr;
struct {
tdb1_unlock(tdb, -1, F_WRLCK);
return 0;
}
-
-
-
-/*
- return the size of the freelist - used to decide if we should repack
-*/
-_PUBLIC_ int tdb1_freelist_size(struct tdb1_context *tdb)
-{
- tdb1_off_t ptr;
- int count=0;
-
- if (tdb1_lock(tdb, -1, F_RDLCK) == -1) {
- return -1;
- }
-
- ptr = TDB1_FREELIST_TOP;
- while (tdb1_ofs_read(tdb, ptr, &ptr) == 0 && ptr != 0) {
- count++;
- }
-
- tdb1_unlock(tdb, -1, F_RDLCK);
- return count;
-}
projects / ccan / blobdiff