summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorRusty Russell <rusty@rustcorp.com.au>2011-09-14 07:32:13 +0930
committerRusty Russell <rusty@rustcorp.com.au>2011-09-14 07:32:13 +0930
commite613effeae7c9373c9e635fc708ec2ce29661d4c (patch)
treed8cdb019f54302de6aa813a62a34e036cf9c7faf
parent50484d4bede6b59706457e44a32cbe2d3e9c28d2 (diff)
downloadsamba-e613effeae7c9373c9e635fc708ec2ce29661d4c.tar.gz
samba-e613effeae7c9373c9e635fc708ec2ce29661d4c.tar.bz2
samba-e613effeae7c9373c9e635fc708ec2ce29661d4c.zip
tdb2: make TDB1 code use tdb2's TDB_ERROR and tdb_logerr()
To do this, we make sure that the first few fields of tdb1_context and tdb_context are the same. This sweep also fixes up a few paths where we weren't setting tdb->ecode before our old logging function. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au> (Imported from CCAN commit 919937354a331bb964564a11b5a5b80403ff8db9)
-rw-r--r--lib/tdb2/private.h6
-rw-r--r--lib/tdb2/tdb1.h27
-rw-r--r--lib/tdb2/tdb1_check.c84
-rw-r--r--lib/tdb2/tdb1_freelist.c31
-rw-r--r--lib/tdb2/tdb1_io.c104
-rw-r--r--lib/tdb2/tdb1_lock.c72
-rw-r--r--lib/tdb2/tdb1_open.c98
-rw-r--r--lib/tdb2/tdb1_private.h34
-rw-r--r--lib/tdb2/tdb1_summary.c8
-rw-r--r--lib/tdb2/tdb1_tdb.c94
-rw-r--r--lib/tdb2/tdb1_transaction.c231
-rw-r--r--lib/tdb2/tdb1_traverse.c33
-rw-r--r--lib/tdb2/test/run-tdb1-3G-file.c8
-rw-r--r--lib/tdb2/test/run-tdb1-check.c2
-rw-r--r--lib/tdb2/test/run-tdb1-endian.c4
-rw-r--r--lib/tdb2/test/run-tdb1-incompatible.c7
-rw-r--r--lib/tdb2/test/run-tdb1-nested-transactions.c2
-rw-r--r--lib/tdb2/test/run-tdb1-readonly-check.c2
-rw-r--r--lib/tdb2/test/run-tdb1-rwlock-check.c7
-rw-r--r--lib/tdb2/test/run-tdb1-wronghash-fail.c7
-rw-r--r--lib/tdb2/test/run-tdb1.c4
-rw-r--r--lib/tdb2/test/tdb1-external-agent.c2
-rw-r--r--lib/tdb2/test/tdb1-logging.c19
23 files changed, 489 insertions, 397 deletions
diff --git a/lib/tdb2/private.h b/lib/tdb2/private.h
index fd848cf65b..f2e458cdf9 100644
--- a/lib/tdb2/private.h
+++ b/lib/tdb2/private.h
@@ -348,6 +348,9 @@ struct tdb_context {
void *data);
void *log_data;
+ /* Last error we returned. */
+ enum TDB_ERROR last_error;
+
/* Open flags passed to tdb_open. */
int open_flags;
@@ -387,9 +390,6 @@ struct tdb_context {
/* Direct access information */
struct tdb_access_hdr *access;
- /* Last error we returned. */
- enum TDB_ERROR last_error;
-
/* The actual file information */
struct tdb_file *file;
};
diff --git a/lib/tdb2/tdb1.h b/lib/tdb2/tdb1.h
index 8ce5fa9d07..8b3130ad2a 100644
--- a/lib/tdb2/tdb1.h
+++ b/lib/tdb2/tdb1.h
@@ -55,39 +55,18 @@
#define TDB1_DISALLOW_NESTING 1024 /** Disallow transactions to nest */
#define TDB1_INCOMPATIBLE_HASH 2048 /** Better hashing: can't be opened by tdb < 1.2.6. */
-/** The tdb error codes */
-enum TDB1_ERROR {TDB1_SUCCESS=0, TDB1_ERR_CORRUPT, TDB1_ERR_IO, TDB1_ERR_LOCK,
- TDB1_ERR_OOM, TDB1_ERR_EXISTS, TDB1_ERR_NOLOCK, TDB1_ERR_LOCK_TIMEOUT,
- TDB1_ERR_NOEXIST, TDB1_ERR_EINVAL, TDB1_ERR_RDONLY,
- TDB1_ERR_NESTING};
-
-/** Debugging uses one of the following levels */
-enum tdb1_debug_level {TDB1_DEBUG_FATAL = 0, TDB1_DEBUG_ERROR,
- TDB1_DEBUG_WARNING, TDB1_DEBUG_TRACE};
-
/** The tdb data structure */
typedef struct TDB1_DATA {
unsigned char *dptr;
size_t dsize;
} TDB1_DATA;
-#ifndef PRINTF_ATTRIBUTE
-#if (__GNUC__ >= 3)
-/** Use gcc attribute to check printf fns. a1 is the 1-based index of
- * the parameter containing the format, and a2 the index of the first
- * argument. Note that some gcc 2.x versions don't handle this
- * properly **/
-#define PRINTF_ATTRIBUTE(a1, a2) __attribute__ ((format (__printf__, a1, a2)))
-#else
-#define PRINTF_ATTRIBUTE(a1, a2)
-#endif
-#endif
-
/** This is the context structure that is returned from a db open. */
typedef struct tdb1_context TDB1_CONTEXT;
typedef int (*tdb1_traverse_func)(struct tdb1_context *, TDB1_DATA, TDB1_DATA, void *);
-typedef void (*tdb1_log_func)(struct tdb1_context *, enum tdb1_debug_level, const char *, ...) PRINTF_ATTRIBUTE(3, 4);
+typedef void (*tdb1_log_func)(struct tdb1_context *, enum tdb_log_level, enum TDB_ERROR,
+ const char *, void *);
typedef unsigned int (*tdb1_hash_func)(TDB1_DATA *key);
struct tdb1_logging_context {
@@ -138,8 +117,6 @@ int tdb1_lockall_read(struct tdb1_context *tdb);
int tdb1_unlockall_read(struct tdb1_context *tdb);
-tdb1_log_func tdb1_log_fn(struct tdb1_context *tdb);
-
int tdb1_transaction_start(struct tdb1_context *tdb);
int tdb1_transaction_prepare_commit(struct tdb1_context *tdb);
diff --git a/lib/tdb2/tdb1_check.c b/lib/tdb2/tdb1_check.c
index 306cd7e05f..f0eb32bdef 100644
--- a/lib/tdb2/tdb1_check.c
+++ b/lib/tdb2/tdb1_check.c
@@ -61,8 +61,8 @@ static bool tdb1_check_header(struct tdb1_context *tdb, tdb1_off_t *recovery)
return true;
corrupt:
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "Header is corrupt\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Header is corrupt\n");
return false;
}
@@ -75,21 +75,21 @@ static bool tdb1_check_record(struct tdb1_context *tdb,
/* Check rec->next: 0 or points to record offset, aligned. */
if (rec->next > 0 && rec->next < TDB1_DATA_START(tdb->header.hash_size)){
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d too small next %d\n",
- off, rec->next));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d too small next %d\n",
+ off, rec->next);
goto corrupt;
}
if (rec->next + sizeof(*rec) < rec->next) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d too large next %d\n",
- off, rec->next));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d too large next %d\n",
+ off, rec->next);
goto corrupt;
}
if ((rec->next % TDB1_ALIGNMENT) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d misaligned next %d\n",
- off, rec->next));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d misaligned next %d\n",
+ off, rec->next);
goto corrupt;
}
if (tdb->methods->tdb1_oob(tdb, rec->next+sizeof(*rec), 0))
@@ -97,16 +97,16 @@ static bool tdb1_check_record(struct tdb1_context *tdb,
/* Check rec_len: similar to rec->next, implies next record. */
if ((rec->rec_len % TDB1_ALIGNMENT) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d misaligned length %d\n",
- off, rec->rec_len));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d misaligned length %d\n",
+ off, rec->rec_len);
goto corrupt;
}
/* Must fit tailer. */
if (rec->rec_len < sizeof(tailer)) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d too short length %d\n",
- off, rec->rec_len));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d too short length %d\n",
+ off, rec->rec_len);
goto corrupt;
}
/* OOB allows "right at the end" access, so this works for last rec. */
@@ -118,15 +118,15 @@ static bool tdb1_check_record(struct tdb1_context *tdb,
&tailer) == -1)
goto corrupt;
if (tailer != sizeof(*rec) + rec->rec_len) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d invalid tailer\n", off));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d invalid tailer\n", off);
goto corrupt;
}
return true;
corrupt:
- tdb->ecode = TDB1_ERR_CORRUPT;
+ tdb->last_error = TDB_ERR_CORRUPT;
return false;
}
@@ -246,8 +246,8 @@ static bool tdb1_check_used_record(struct tdb1_context *tdb,
/* key + data + tailer must fit in record */
if (rec->key_len + rec->data_len + sizeof(tdb1_off_t) > rec->rec_len) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d too short for contents\n", off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d too short for contents\n", off);
return false;
}
@@ -256,8 +256,8 @@ static bool tdb1_check_used_record(struct tdb1_context *tdb,
return false;
if (tdb->hash_fn(&key) != rec->full_hash) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Record offset %d has incorrect hash\n", off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Record offset %d has incorrect hash\n", off);
goto fail_put_key;
}
@@ -353,8 +353,8 @@ int tdb1_check(struct tdb1_context *tdb,
/* We should have the whole header, too. */
if (tdb->map_size < TDB1_DATA_START(tdb->header.hash_size)) {
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "File too short for hashes\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "File too short for hashes\n");
goto unlock;
}
@@ -363,7 +363,7 @@ int tdb1_check(struct tdb1_context *tdb,
1, sizeof(hashes[0]) * (1+tdb->header.hash_size)
+ BITMAP_BITS / CHAR_BIT * (1+tdb->header.hash_size));
if (!hashes) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
goto unlock;
}
@@ -410,26 +410,25 @@ int tdb1_check(struct tdb1_context *tdb,
if (dead < sizeof(rec))
goto corrupt;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Dead space at %d-%d (of %u)\n",
- off, off + dead, tdb->map_size));
+ tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
+ "Dead space at %d-%d (of %u)\n",
+ off, off + dead, tdb->map_size);
rec.rec_len = dead - sizeof(rec);
break;
case TDB1_RECOVERY_MAGIC:
if (recovery_start != off) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Unexpected recovery record at offset %d\n",
- off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Unexpected recovery record at offset %d\n",
+ off);
goto free;
}
found_recovery = true;
break;
default: ;
corrupt:
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Bad magic 0x%x at offset %d\n",
- rec.magic, off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Bad magic 0x%x at offset %d\n",
+ rec.magic, off);
goto free;
}
}
@@ -440,9 +439,8 @@ int tdb1_check(struct tdb1_context *tdb,
unsigned int i;
for (i = 0; i < BITMAP_BITS / CHAR_BIT; i++) {
if (hashes[h][i] != 0) {
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Hashes do not match records\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Hashes do not match records\n");
goto free;
}
}
@@ -450,9 +448,9 @@ int tdb1_check(struct tdb1_context *tdb,
/* We must have found recovery area if there was one. */
if (recovery_start != 0 && !found_recovery) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Expected a recovery area at %u\n",
- recovery_start));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "Expected a recovery area at %u\n",
+ recovery_start);
goto free;
}
diff --git a/lib/tdb2/tdb1_freelist.c b/lib/tdb2/tdb1_freelist.c
index ba93b5892c..cf2eeb7feb 100644
--- a/lib/tdb2/tdb1_freelist.c
+++ b/lib/tdb2/tdb1_freelist.c
@@ -36,18 +36,18 @@ int tdb1_rec_free_read(struct tdb1_context *tdb, tdb1_off_t off, struct tdb1_rec
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)
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)
@@ -78,7 +78,8 @@ int tdb1_free(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *r
/* 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;
}
@@ -90,7 +91,8 @@ int tdb1_free(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *r
/* 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;
}
@@ -108,7 +110,8 @@ int tdb1_free(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *r
/* 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));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free: left read failed at %u (%u)", left, leftsize);
goto update;
}
@@ -119,11 +122,13 @@ int tdb1_free(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *r
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;
}
tdb1_unlock(tdb, -1, F_WRLCK);
@@ -139,7 +144,9 @@ update:
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;
}
diff --git a/lib/tdb2/tdb1_io.c b/lib/tdb2/tdb1_io.c
index 212e94ae14..cd6efc34b1 100644
--- a/lib/tdb2/tdb1_io.c
+++ b/lib/tdb2/tdb1_io.c
@@ -43,32 +43,30 @@ static int tdb1_oob(struct tdb1_context *tdb, tdb1_off_t len, int probe)
return 0;
if (tdb->flags & TDB1_INTERNAL) {
if (!probe) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_oob len %d beyond internal malloc size %d\n",
- (int)len, (int)tdb->map_size));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_oob len %d beyond internal malloc size %d",
+ (int)len, (int)tdb->map_size);
}
return -1;
}
if (fstat(tdb->fd, &st) == -1) {
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = TDB_ERR_IO;
return -1;
}
if (st.st_size < (size_t)len) {
if (!probe) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_oob len %d beyond eof at %d\n",
- (int)len, (int)st.st_size));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_oob len %d beyond eof at %d",
+ (int)len, (int)st.st_size);
}
return -1;
}
/* Unmap, update size, remap */
if (tdb1_munmap(tdb) == -1) {
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = TDB_ERR_IO;
return -1;
}
tdb->map_size = st.st_size;
@@ -85,7 +83,7 @@ static int tdb1_write(struct tdb1_context *tdb, tdb1_off_t off,
}
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_RDONLY;
+ tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
@@ -97,26 +95,26 @@ static int tdb1_write(struct tdb1_context *tdb, tdb1_off_t off,
} else {
ssize_t written = pwrite(tdb->fd, buf, len, off);
if ((written != (ssize_t)len) && (written != -1)) {
- /* try once more */
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_write: wrote only "
- "%d of %d bytes at %d, trying once more\n",
- (int)written, len, off));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
+ "tdb1_write: wrote only "
+ "%d of %d bytes at %d, trying once more",
+ (int)written, len, off);
written = pwrite(tdb->fd, (const char *)buf+written,
len-written,
off+written);
}
if (written == -1) {
/* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_write failed at %d "
- "len=%d (%s)\n", off, len, strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_write failed at %d "
+ "len=%d (%s)",
+ off, len, strerror(errno));
return -1;
} else if (written != (ssize_t)len) {
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_write: failed to "
- "write %d bytes at %d in two attempts\n",
- len, off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_write: failed to "
+ "write %d bytes at %d in two attempts",
+ len, off);
return -1;
}
}
@@ -147,11 +145,12 @@ static int tdb1_read(struct tdb1_context *tdb, tdb1_off_t off, void *buf,
ssize_t ret = pread(tdb->fd, buf, len, off);
if (ret != (ssize_t)len) {
/* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_read failed at %d "
- "len=%d ret=%d (%s) map_size=%d\n",
- (int)off, (int)len, (int)ret, strerror(errno),
- (int)tdb->map_size));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_read failed at %d "
+ "len=%d ret=%d (%s) map_size=%d",
+ (int)off, (int)len, (int)ret,
+ strerror(errno),
+ (int)tdb->map_size);
return -1;
}
}
@@ -223,8 +222,9 @@ void tdb1_mmap(struct tdb1_context *tdb)
if (tdb->map_ptr == MAP_FAILED) {
tdb->map_ptr = NULL;
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_mmap failed for size %d (%s)\n",
- tdb->map_size, strerror(errno)));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
+ "tdb1_mmap failed for size %d (%s)",
+ tdb->map_size, strerror(errno));
}
} else {
tdb->map_ptr = NULL;
@@ -241,7 +241,7 @@ static int tdb1_expand_file(struct tdb1_context *tdb, tdb1_off_t size, tdb1_off_
char buf[8192];
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_RDONLY;
+ tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
@@ -257,8 +257,10 @@ static int tdb1_expand_file(struct tdb1_context *tdb, tdb1_off_t size, tdb1_off_
errno = ENOSPC;
}
if (written != 1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "expand_file to %d failed (%s)\n",
- size+addition, strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "expand_file to %d failed (%s)",
+ size+addition,
+ strerror(errno));
return -1;
}
}
@@ -276,19 +278,22 @@ static int tdb1_expand_file(struct tdb1_context *tdb, tdb1_off_t size, tdb1_off_
}
if (written == 0) {
/* give up, trying to provide a useful errno */
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "expand_file write "
- "returned 0 twice: giving up!\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "expand_file write "
+ "returned 0 twice: giving up!");
errno = ENOSPC;
return -1;
} else if (written == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "expand_file write of "
- "%d bytes failed (%s)\n", (int)n,
- strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "expand_file write of "
+ "%d bytes failed (%s)", (int)n,
+ strerror(errno));
return -1;
} else if (written != n) {
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "expand_file: wrote "
- "only %d of %d bytes - retrying\n", (int)written,
- (int)n));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
+ "expand_file: wrote "
+ "only %d of %d bytes - retrying",
+ (int)written, (int)n);
}
addition -= written;
size += written;
@@ -305,7 +310,8 @@ int tdb1_expand(struct tdb1_context *tdb, tdb1_off_t size)
tdb1_off_t offset, new_size, top_size, map_size;
if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "lock failed in tdb1_expand\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "lock failed in tdb1_expand");
return -1;
}
@@ -406,10 +412,10 @@ unsigned char *tdb1_alloc_read(struct tdb1_context *tdb, tdb1_off_t offset, tdb1
/* some systems don't like zero length malloc */
if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_OOM;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,"tdb1_alloc_read malloc failed len=%d (%s)\n",
- len, strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "tdb1_alloc_read malloc failed"
+ " len=%d (%s)",
+ len, strerror(errno));
return NULL;
}
if (tdb->methods->tdb1_read(tdb, offset, buf, len, 0) == -1) {
@@ -459,9 +465,9 @@ int tdb1_rec_read(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_recor
if (tdb->methods->tdb1_read(tdb, offset, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
return -1;
if (TDB1_BAD_MAGIC(rec)) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_rec_read bad magic 0x%x at offset=%d",
+ rec->magic, offset);
return -1;
}
return tdb->methods->tdb1_oob(tdb, rec->next+sizeof(*rec), 0);
diff --git a/lib/tdb2/tdb1_lock.c b/lib/tdb2/tdb1_lock.c
index a33c851c17..68f394aad2 100644
--- a/lib/tdb2/tdb1_lock.c
+++ b/lib/tdb2/tdb1_lock.c
@@ -139,7 +139,7 @@ int tdb1_brlock(struct tdb1_context *tdb,
}
if ((rw_type == F_WRLCK) && (tdb->read_only || tdb->traverse_read)) {
- tdb->ecode = TDB1_ERR_RDONLY;
+ tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
@@ -149,13 +149,14 @@ int tdb1_brlock(struct tdb1_context *tdb,
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
/* Generic lock error. errno set by fcntl.
* EAGAIN is an expected return from non-blocking
* locks. */
if (!(flags & TDB1_LOCK_PROBE) && errno != EAGAIN) {
- TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n",
- tdb->fd, offset, rw_type, flags, (int)len));
+ tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d",
+ tdb->fd, offset, rw_type, flags, (int)len);
}
return -1;
}
@@ -176,8 +177,10 @@ int tdb1_brunlock(struct tdb1_context *tdb,
} while (ret == -1 && errno == EINTR);
if (ret == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n",
- tdb->fd, offset, rw_type, (int)len));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_brunlock failed (fd=%d) at offset"
+ " %d rw_type=%d len=%d",
+ tdb->fd, offset, rw_type, (int)len);
}
return ret;
}
@@ -193,15 +196,17 @@ int tdb1_allrecord_upgrade(struct tdb1_context *tdb)
int count = 1000;
if (tdb->allrecord_lock.count != 1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "tdb1_allrecord_upgrade failed: count %u too high\n",
- tdb->allrecord_lock.count));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_allrecord_upgrade failed: "
+ "count %u too high",
+ tdb->allrecord_lock.count);
return -1;
}
if (tdb->allrecord_lock.off != 1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "tdb1_allrecord_upgrade failed: already upgraded?\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_allrecord_upgrade failed:"
+ " already upgraded?");
return -1;
}
@@ -221,7 +226,8 @@ int tdb1_allrecord_upgrade(struct tdb1_context *tdb)
tv.tv_usec = 1;
select(0, NULL, NULL, NULL, &tv);
}
- TDB1_LOG((tdb, TDB1_DEBUG_TRACE,"tdb1_allrecord_upgrade failed\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_allrecord_upgrade failed");
return -1;
}
@@ -245,9 +251,10 @@ int tdb1_nest_lock(struct tdb1_context *tdb, uint32_t offset, int ltype,
struct tdb1_lock_type *new_lck;
if (offset >= lock_offset(tdb->header.hash_size)) {
- tdb->ecode = TDB1_ERR_LOCK;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,"tdb1_lock: invalid offset %u for ltype=%d\n",
- offset, ltype));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_lock: invalid offset %u for"
+ " ltype=%d",
+ offset, ltype);
return -1;
}
if (tdb->flags & TDB1_NOLOCK)
@@ -332,7 +339,7 @@ static int tdb1_lock_list(struct tdb1_context *tdb, int list, int ltype,
}
if (tdb->allrecord_lock.count) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
ret = -1;
} else {
/* Only check when we grab first data lock. */
@@ -358,8 +365,9 @@ int tdb1_lock(struct tdb1_context *tdb, int list, int ltype)
ret = tdb1_lock_list(tdb, list, ltype, TDB1_LOCK_WAIT);
if (ret) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_lock failed on list %d "
- "ltype=%d (%s)\n", list, ltype, strerror(errno)));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_lock failed on list %d "
+ "ltype=%d (%s)", list, ltype, strerror(errno));
}
return ret;
}
@@ -374,13 +382,16 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype)
/* Sanity checks */
if (offset >= lock_offset(tdb->header.hash_size)) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: offset %u invalid (%d)\n", offset, tdb->header.hash_size));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_unlock: offset %u invalid (%d)",
+ offset, tdb->header.hash_size);
return ret;
}
lck = tdb1_find_nestlock(tdb, offset);
if ((lck == NULL) || (lck->count == 0)) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: count is 0\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+ "tdb1_unlock: count is 0");
return -1;
}
@@ -413,8 +424,6 @@ int tdb1_nest_unlock(struct tdb1_context *tdb, uint32_t offset, int ltype)
SAFE_FREE(tdb->lockrecs);
}
- if (ret)
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlock: An error occurred unlocking!\n"));
return ret;
}
@@ -427,7 +436,7 @@ int tdb1_unlock(struct tdb1_context *tdb, int list, int ltype)
}
if (tdb->allrecord_lock.count) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
@@ -457,7 +466,7 @@ static int tdb1_allrecord_check(struct tdb1_context *tdb, int ltype,
{
/* There are no locks on read-only dbs */
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
@@ -468,19 +477,19 @@ static int tdb1_allrecord_check(struct tdb1_context *tdb, int ltype,
if (tdb->allrecord_lock.count) {
/* a global lock of a different type exists */
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
if (tdb1_have_extra_locks(tdb)) {
/* can't combine global and chain locks */
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
if (upgradable && ltype != F_RDLCK) {
/* tdb error: you can't upgrade a write lock! */
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
return 1;
@@ -577,19 +586,19 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype)
{
/* There are no locks on read-only dbs */
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
if (tdb->allrecord_lock.count == 0) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
/* Upgradable locks are marked as write locks. */
if (tdb->allrecord_lock.ltype != ltype
&& (!tdb->allrecord_lock.off || ltype != F_RDLCK)) {
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = TDB_ERR_LOCK;
return -1;
}
@@ -599,7 +608,8 @@ int tdb1_allrecord_unlock(struct tdb1_context *tdb, int ltype)
}
if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_unlockall failed (%s)\n", strerror(errno)));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_unlockall failed (%s)", strerror(errno));
return -1;
}
diff --git a/lib/tdb2/tdb1_open.c b/lib/tdb2/tdb1_open.c
index aed4df6558..e1f1605366 100644
--- a/lib/tdb2/tdb1_open.c
+++ b/lib/tdb2/tdb1_open.c
@@ -60,7 +60,7 @@ static int tdb1_new_database(struct tdb1_context *tdb, int hash_size)
/* We make it up in memory, then write it out if not internal */
size = sizeof(struct tdb1_header) + (hash_size+1)*sizeof(tdb1_off_t);
if (!(newdb = (struct tdb1_header *)calloc(size, 1))) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
return -1;
}
@@ -135,12 +135,6 @@ struct tdb1_context *tdb1_open(const char *name, int hash_size, int tdb1_flags,
return tdb1_open_ex(name, hash_size, tdb1_flags, open_flags, mode, NULL, NULL);
}
-/* a default logging function */
-static void null_log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...) PRINTF_ATTRIBUTE(3, 4);
-static void null_log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...)
-{
-}
-
static bool check_header_hash(struct tdb1_context *tdb,
bool default_hash, uint32_t *m1, uint32_t *m2)
{
@@ -188,11 +182,10 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
tdb->flags = tdb1_flags;
tdb->open_flags = open_flags;
if (log_ctx) {
- tdb->log = *log_ctx;
- } else {
- tdb->log.log_fn = null_log_fn;
- tdb->log.log_private = NULL;
- }
+ tdb->log_fn = log_ctx->log_fn;
+ tdb->log_data = log_ctx->log_private;
+ } else
+ tdb->log_fn = NULL;
if (name == NULL && (tdb1_flags & TDB1_INTERNAL)) {
name = "__TDB1_INTERNAL__";
@@ -200,7 +193,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
if (name == NULL) {
tdb->name = (char *)"__NULL__";
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: called with name == NULL\n"));
+ tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_open_ex: called with name == NULL");
tdb->name = NULL;
errno = EINVAL;
goto fail;
@@ -213,8 +207,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
* work in case of an error.
*/
tdb->name = (char *)name;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: can't strdup(%s)\n",
- name));
+ tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "tdb1_open_ex: can't strdup(%s)", name);
tdb->name = NULL;
errno = ENOMEM;
goto fail;
@@ -242,8 +236,9 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
tdb->max_dead_records = (tdb1_flags & TDB1_VOLATILE) ? 5 : 0;
if ((open_flags & O_ACCMODE) == O_WRONLY) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: can't open tdb %s write-only\n",
- name));
+ tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_open_ex: can't open tdb %s write-only",
+ name);
errno = EINVAL;
goto fail;
}
@@ -259,9 +254,9 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
if ((tdb->flags & TDB1_ALLOW_NESTING) &&
(tdb->flags & TDB1_DISALLOW_NESTING)) {
- tdb->ecode = TDB1_ERR_NESTING;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
- "allow_nesting and disallow_nesting are not allowed together!"));
+ tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_open_ex: "
+ "allow_nesting and disallow_nesting are not allowed together!");
errno = EINVAL;
goto fail;
}
@@ -279,15 +274,17 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
tdb->flags |= (TDB1_NOLOCK | TDB1_NOMMAP);
tdb->flags &= ~TDB1_CLEAR_IF_FIRST;
if (tdb1_new_database(tdb, hash_size) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: tdb1_new_database failed!"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_open_ex: tdb1_new_database failed!");
goto fail;
}
goto internal;
}
if ((tdb->fd = open(name, open_flags, mode)) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_open_ex: could not open file %s: %s\n",
- name, strerror(errno)));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_open_ex: could not open file %s: %s",
+ name, strerror(errno));
goto fail; /* errno set by open(2) */
}
@@ -297,8 +294,9 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
/* ensure there is only one process initialising at once */
if (tdb1_nest_lock(tdb, TDB1_OPEN_LOCK, F_WRLCK, TDB1_LOCK_WAIT) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: failed to get open lock on %s: %s\n",
- name, strerror(errno)));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_open_ex: failed to get open lock on %s: %s",
+ name, strerror(errno));
goto fail; /* errno set by tdb1_brlock */
}
@@ -308,9 +306,10 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
(locked = (tdb1_nest_lock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK, TDB1_LOCK_NOWAIT|TDB1_LOCK_PROBE) == 0))) {
open_flags |= O_CREAT;
if (ftruncate(tdb->fd, 0) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
- "failed to truncate %s: %s\n",
- name, strerror(errno)));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_open_ex: "
+ "failed to truncate %s: %s",
+ name, strerror(errno));
goto fail; /* errno set by ftruncate */
}
}
@@ -346,7 +345,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
if (tdb->header.rwlocks != 0 &&
tdb->header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: spinlocks no longer supported\n"));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_open_ex: spinlocks no longer supported");
goto fail;
}
@@ -354,26 +354,28 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
/* older TDB without magic hash references */
tdb->hash_fn = tdb1_old_hash;
} else if (!check_header_hash(tdb, !hash_fn, &magic1, &magic2)) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_open_ex: "
- "%s was not created with %s hash function we are using\n"
- "magic1_hash[0x%08X %s 0x%08X] "
- "magic2_hash[0x%08X %s 0x%08X]\n",
- name, hash_alg,
- tdb->header.magic1_hash,
- (tdb->header.magic1_hash == magic1) ? "==" : "!=",
- magic1,
- tdb->header.magic2_hash,
- (tdb->header.magic2_hash == magic2) ? "==" : "!=",
- magic2));
+ tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_USE_ERROR,
+ "tdb1_open_ex: "
+ "%s was not created with %s hash function we are using\n"
+ "magic1_hash[0x%08X %s 0x%08X] "
+ "magic2_hash[0x%08X %s 0x%08X]",
+ name, hash_alg,
+ tdb->header.magic1_hash,
+ (tdb->header.magic1_hash == magic1) ? "==" : "!=",
+ magic1,
+ tdb->header.magic2_hash,
+ (tdb->header.magic2_hash == magic2) ? "==" : "!=",
+ magic2);
errno = EINVAL;
goto fail;
}
/* Is it already in the open list? If so, fail. */
if (tdb1_already_open(st.st_dev, st.st_ino)) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: "
- "%s (%d,%d) is already open in this process\n",
- name, (int)st.st_dev, (int)st.st_ino));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_USE_ERROR,
+ "tdb1_open_ex: "
+ "%s (%d,%d) is already open in this process",
+ name, (int)st.st_dev, (int)st.st_ino);
errno = EBUSY;
goto fail;
}
@@ -384,9 +386,10 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
tdb1_mmap(tdb);
if (locked) {
if (tdb1_nest_unlock(tdb, TDB1_ACTIVE_LOCK, F_WRLCK) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: "
- "failed to release ACTIVE_LOCK on %s: %s\n",
- name, strerror(errno)));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_open_ex: "
+ "failed to release ACTIVE_LOCK on %s: %s",
+ name, strerror(errno));
goto fail;
}
@@ -433,7 +436,8 @@ struct tdb1_context *tdb1_open_ex(const char *name, int hash_size, int tdb1_flag
}
if (tdb->fd != -1)
if (close(tdb->fd) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_open_ex: failed to close tdb->fd on error!\n"));
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_open_ex: failed to close tdb->fd on error!");
SAFE_FREE(tdb->lockrecs);
SAFE_FREE(tdb->name);
SAFE_FREE(tdb);
diff --git a/lib/tdb2/tdb1_private.h b/lib/tdb2/tdb1_private.h
index 7ce192b9a6..932e76110b 100644
--- a/lib/tdb2/tdb1_private.h
+++ b/lib/tdb2/tdb1_private.h
@@ -28,10 +28,16 @@
#include "private.h"
#include "tdb1.h"
-#include <limits.h>
+/**** FIXME: Type overrides for tdb2, for transition! */
+#define tdb_logerr(tdb, ecode, level, ...) \
+ tdb_logerr((struct tdb_context *)(tdb), (ecode), (level), __VA_ARGS__)
+
+#define tdb_error(tdb) \
+ tdb_error((struct tdb_context *)(tdb))
-/* Temporary wrapper to avoid undue churn in test/ */
-#define tdb1_error(tdb) ((tdb)->ecode)
+/***** END FIXME ***/
+
+#include <limits.h>
/* #define TDB_TRACE 1 */
#ifndef HAVE_GETPAGESIZE
@@ -80,11 +86,6 @@ typedef uint32_t tdb1_off_t;
#define TDB1_PAD_BYTE 0x42
#define TDB1_PAD_U32 0x42424242
-/* NB assumes there is a local variable called "tdb" that is the
- * current context, also takes doubly-parenthesized print-style
- * argument. */
-#define TDB1_LOG(x) tdb->log.log_fn x
-
/* lock offsets */
#define TDB1_OPEN_LOCK 0
#define TDB1_ACTIVE_LOCK 4
@@ -167,7 +168,21 @@ struct tdb1_methods {
};
struct tdb1_context {
+ struct tdb1_context *next;
+
char *name; /* the name of the database */
+
+ /* Logging function */
+ void (*log_fn)(struct tdb1_context *tdb,
+ enum tdb_log_level level,
+ enum TDB_ERROR ecode,
+ const char *message,
+ void *data);
+ void *log_data;
+
+ /* Last error we returned. */
+ enum TDB_ERROR last_error; /* error code for last tdb error */
+
void *map_ptr; /* where it is currently mapped */
int fd; /* open file descriptor for the database */
tdb1_len_t map_size; /* how much space has been mapped */
@@ -177,14 +192,11 @@ struct tdb1_context {
struct tdb1_lock_type allrecord_lock; /* .offset == upgradable */
int num_lockrecs;
struct tdb1_lock_type *lockrecs; /* only real locks, all with count>0 */
- enum TDB1_ERROR ecode; /* error code for last tdb error */
struct tdb1_header header; /* a cached copy of the header */
uint32_t flags; /* the flags passed to tdb1_open */
struct tdb1_traverse_lock travlocks; /* current traversal locks */
- struct tdb1_context *next; /* all tdbs to avoid multiple opens */
dev_t device; /* uniquely identifies this tdb */
ino_t inode; /* uniquely identifies this tdb */
- struct tdb1_logging_context log;
unsigned int (*hash_fn)(TDB1_DATA *key);
int open_flags; /* flags used in the open - needed by reopen */
const struct tdb1_methods *methods;
diff --git a/lib/tdb2/tdb1_summary.c b/lib/tdb2/tdb1_summary.c
index a2d2ae8f2f..b6889bc444 100644
--- a/lib/tdb2/tdb1_summary.c
+++ b/lib/tdb2/tdb1_summary.c
@@ -150,9 +150,11 @@ char *tdb1_summary(struct tdb1_context *tdb)
tally1_add(&dead, rec.rec_len);
break;
default:
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR,
- "Unexpected record magic 0x%x at offset %d\n",
- rec.magic, off));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
+ TDB_LOG_ERROR,
+ "Unexpected record magic 0x%x"
+ " at offset %d",
+ rec.magic, off);
goto unlock;
}
}
diff --git a/lib/tdb2/tdb1_tdb.c b/lib/tdb2/tdb1_tdb.c
index 113ebc0b6d..8023115045 100644
--- a/lib/tdb2/tdb1_tdb.c
+++ b/lib/tdb2/tdb1_tdb.c
@@ -99,13 +99,14 @@ static tdb1_off_t tdb1_find(struct tdb1_context *tdb, TDB1_DATA key, uint32_t ha
}
/* detect tight infinite loop */
if (rec_ptr == r->next) {
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_find: loop detected.\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
+ TDB_LOG_ERROR,
+ "tdb1_find: loop detected.");
return 0;
}
rec_ptr = r->next;
}
- tdb->ecode = TDB1_ERR_NOEXIST;
+ tdb->last_error = TDB_ERR_NOEXIST;
return 0;
}
@@ -157,7 +158,7 @@ static int tdb1_update_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t ha
/* must be long enough key, data and tailer */
if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb1_off_t)) {
- tdb->ecode = TDB1_SUCCESS; /* Not really an error */
+ tdb->last_error = TDB_SUCCESS; /* Not really an error */
return -1;
}
@@ -176,7 +177,7 @@ static int tdb1_update_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t ha
/* find an entry in the database given a key */
/* If an entry doesn't exist tdb1_err will be set to
- * TDB1_ERR_NOEXIST. If a key has no data attached
+ * TDB_ERR_NOEXIST. If a key has no data attached
* then the TDB1_DATA will have zero length but
* a non-zero pointer
*/
@@ -239,7 +240,7 @@ int tdb1_parse_record(struct tdb1_context *tdb, TDB1_DATA key,
if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
/* record not found */
- tdb->ecode = TDB1_ERR_NOEXIST;
+ tdb->last_error = TDB_ERR_NOEXIST;
return -1;
}
@@ -421,7 +422,8 @@ static int tdb1_delete_hash(struct tdb1_context *tdb, TDB1_DATA key, uint32_t ha
}
if (tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_WRLCK) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_WARNING, "tdb1_delete: WARNING tdb1_unlock failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_delete: WARNING tdb1_unlock failed!");
return ret;
}
@@ -474,7 +476,7 @@ static int _tdb1_store(struct tdb1_context *tdb, TDB1_DATA key,
/* check for it existing, on insert. */
if (flag == TDB1_INSERT) {
if (tdb1_exists_hash(tdb, key, hash)) {
- tdb->ecode = TDB1_ERR_EXISTS;
+ tdb->last_error = TDB_ERR_EXISTS;
goto fail;
}
} else {
@@ -482,7 +484,7 @@ static int _tdb1_store(struct tdb1_context *tdb, TDB1_DATA key,
if (tdb1_update_hash(tdb, key, hash, dbuf) == 0) {
goto done;
}
- if (tdb->ecode == TDB1_ERR_NOEXIST &&
+ if (tdb->last_error == TDB_ERR_NOEXIST &&
flag == TDB1_MODIFY) {
/* if the record doesn't exist and we are in TDB1_MODIFY mode then
we should fail the store */
@@ -490,7 +492,7 @@ static int _tdb1_store(struct tdb1_context *tdb, TDB1_DATA key,
}
}
/* reset the error code potentially set by the tdb1_update() */
- tdb->ecode = TDB1_SUCCESS;
+ tdb->last_error = TDB_SUCCESS;
/* delete any existing record - if it doesn't exist we don't
care. Doing this first reduces fragmentation, and avoids
@@ -502,7 +504,7 @@ static int _tdb1_store(struct tdb1_context *tdb, TDB1_DATA key,
fails and we are left with a dead spot in the tdb. */
if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
goto fail;
}
@@ -600,7 +602,7 @@ int tdb1_store(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA dbuf, int flag
int ret;
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_RDONLY;
+ tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
@@ -645,7 +647,7 @@ int tdb1_append(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA new_dbuf)
}
if (dbuf.dptr == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
goto failed;
}
@@ -662,16 +664,6 @@ failed:
/*
- return the current logging function
- useful for external tdb routines that wish to log tdb errors
-*/
-tdb1_log_func tdb1_log_fn(struct tdb1_context *tdb)
-{
- return tdb->log.log_fn;
-}
-
-
-/*
get the tdb sequence number. Only makes sense if the writers opened
with TDB1_SEQNUM set. Note that this sequence number will wrap quite
quickly, so it should only be used for a 'has something changed'
@@ -707,13 +699,16 @@ static int tdb1_free_region(struct tdb1_context *tdb, tdb1_off_t offset, ssize_t
return 0;
}
if (length + offset > tdb->map_size) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_free_region: adding region beyond end of file\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_free_region: adding region beyond"
+ " end of file");
return -1;
}
memset(&rec,'\0',sizeof(rec));
rec.rec_len = length - sizeof(rec);
if (tdb1_free(tdb, offset, &rec) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_free_region: failed to add free record\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_free_region: failed to add free record");
return -1;
}
return 0;
@@ -744,14 +739,16 @@ int tdb1_wipe_all(struct tdb1_context *tdb)
tdb1_wipe_all() in a transaction will increase the size of
the tdb by the size of the recovery area */
if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_wipe_all: failed to read recovery head\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_wipe_all: failed to read recovery head");
goto failed;
}
if (recovery_head != 0) {
struct tdb1_record rec;
if (tdb->methods->tdb1_read(tdb, recovery_head, &rec, sizeof(rec), TDB1_DOCONV()) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_wipe_all: failed to read recovery record\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_wipe_all: failed to read recovery record");
return -1;
}
recovery_size = rec.rec_len + sizeof(rec);
@@ -760,14 +757,16 @@ int tdb1_wipe_all(struct tdb1_context *tdb)
/* wipe the hashes */
for (i=0;i<tdb->header.hash_size;i++) {
if (tdb1_ofs_write(tdb, TDB1_HASH_TOP(i), &offset) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_wipe_all: failed to write hash %d\n", i));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_wipe_all: failed to write hash %d", i);
goto failed;
}
}
/* wipe the freelist */
if (tdb1_ofs_write(tdb, TDB1_FREELIST_TOP, &offset) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_wipe_all: failed to write freelist\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_wipe_all: failed to write freelist");
goto failed;
}
@@ -800,7 +799,8 @@ int tdb1_wipe_all(struct tdb1_context *tdb)
}
if (tdb1_unlockall(tdb) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL,"tdb1_wipe_all: failed to unlock\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_wipe_all: failed to unlock");
goto failed;
}
@@ -812,7 +812,7 @@ failed:
}
struct traverse_state {
- bool error;
+ enum TDB_ERROR error;
struct tdb1_context *dest_db;
};
@@ -823,7 +823,7 @@ static int repack_traverse(struct tdb1_context *tdb, TDB1_DATA key, TDB1_DATA da
{
struct traverse_state *state = (struct traverse_state *)private_data;
if (tdb1_store(state->dest_db, key, data, TDB1_INSERT) != 0) {
- state->error = true;
+ state->error = state->dest_db->last_error;
return -1;
}
return 0;
@@ -838,53 +838,60 @@ int tdb1_repack(struct tdb1_context *tdb)
struct traverse_state state;
if (tdb1_transaction_start(tdb) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to start transaction\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ __location__ " Failed to start transaction");
return -1;
}
tmp_db = tdb1_open("tmpdb", tdb1_hash_size(tdb), TDB1_INTERNAL, O_RDWR|O_CREAT, 0);
if (tmp_db == NULL) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to create tmp_db\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ __location__ " Failed to create tmp_db");
tdb1_transaction_cancel(tdb);
return -1;
}
- state.error = false;
+ state.error = TDB_SUCCESS;
state.dest_db = tmp_db;
if (tdb1_traverse_read(tdb, repack_traverse, &state) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to traverse copying out\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ __location__ " Failed to traverse copying out");
tdb1_transaction_cancel(tdb);
tdb1_close(tmp_db);
return -1;
}
- if (state.error) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Error during traversal\n"));
+ if (state.error != TDB_SUCCESS) {
+ tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
+ __location__ " Error during traversal");
tdb1_transaction_cancel(tdb);
tdb1_close(tmp_db);
return -1;
}
if (tdb1_wipe_all(tdb) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to wipe database\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ __location__ " Failed to wipe database\n");
tdb1_transaction_cancel(tdb);
tdb1_close(tmp_db);
return -1;
}
- state.error = false;
+ state.error = TDB_SUCCESS;
state.dest_db = tdb;
if (tdb1_traverse_read(tmp_db, repack_traverse, &state) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to traverse copying back\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ __location__ " Failed to traverse copying back");
tdb1_transaction_cancel(tdb);
tdb1_close(tmp_db);
return -1;
}
if (state.error) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Error during second traversal\n"));
+ tdb->last_error = tdb_logerr(tdb, state.error, TDB_LOG_ERROR,
+ __location__ " Error during second traversal");
tdb1_transaction_cancel(tdb);
tdb1_close(tmp_db);
return -1;
@@ -893,7 +900,8 @@ int tdb1_repack(struct tdb1_context *tdb)
tdb1_close(tmp_db);
if (tdb1_transaction_commit(tdb) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, __location__ " Failed to commit\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ __location__ " Failed to commit");
return -1;
}
diff --git a/lib/tdb2/tdb1_transaction.c b/lib/tdb2/tdb1_transaction.c
index b09a2b3c10..165fd7f972 100644
--- a/lib/tdb2/tdb1_transaction.c
+++ b/lib/tdb2/tdb1_transaction.c
@@ -97,7 +97,7 @@
- if TDB1_DISALLOW_NESTING is passed to flags in tdb open, or added using
tdb1_add_flags() transaction nesting is disabled.
It resets the TDB1_ALLOW_NESTING flag, as both cannot be used together.
- An attempt create a nested transaction will fail with TDB1_ERR_NESTING.
+ An attempt create a nested transaction will fail with TDB_ERR_EINVAL.
The default is that transaction nesting is allowed.
Note: this default may change in future versions of tdb.
*/
@@ -194,8 +194,9 @@ static int transaction1_read(struct tdb1_context *tdb, tdb1_off_t off, void *buf
return 0;
fail:
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "transaction_read: failed at off=%d len=%d\n", off, len));
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "transaction_read: failed at off=%d len=%d",
+ off, len);
tdb->transaction->transaction_error = 1;
return -1;
}
@@ -211,8 +212,9 @@ static int transaction1_write(struct tdb1_context *tdb, tdb1_off_t off,
/* Only a commit is allowed on a prepared transaction */
if (tdb->transaction->prepared) {
- tdb->ecode = TDB1_ERR_EINVAL;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "transaction_write: transaction already prepared, write not allowed\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "transaction_write: transaction already"
+ " prepared, write not allowed");
tdb->transaction->transaction_error = 1;
return -1;
}
@@ -257,7 +259,7 @@ static int transaction1_write(struct tdb1_context *tdb, tdb1_off_t off,
(blk+1)*sizeof(uint8_t *));
}
if (new_blocks == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
goto fail;
}
memset(&new_blocks[tdb->transaction->num_blocks], 0,
@@ -271,7 +273,7 @@ static int transaction1_write(struct tdb1_context *tdb, tdb1_off_t off,
if (tdb->transaction->blocks[blk] == NULL) {
tdb->transaction->blocks[blk] = (uint8_t *)calloc(tdb->transaction->block_size, 1);
if (tdb->transaction->blocks[blk] == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
tdb->transaction->transaction_error = 1;
return -1;
}
@@ -284,7 +286,7 @@ static int transaction1_write(struct tdb1_context *tdb, tdb1_off_t off,
tdb->transaction->blocks[blk],
len2, 0) != 0) {
SAFE_FREE(tdb->transaction->blocks[blk]);
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = TDB_ERR_IO;
goto fail;
}
if (blk == tdb->transaction->num_blocks-1) {
@@ -308,8 +310,9 @@ static int transaction1_write(struct tdb1_context *tdb, tdb1_off_t off,
return 0;
fail:
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "transaction_write: failed at off=%d len=%d\n",
- (blk*tdb->transaction->block_size) + off, len));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "transaction_write: failed at off=%d len=%d",
+ (blk*tdb->transaction->block_size) + off, len);
tdb->transaction->transaction_error = 1;
return -1;
}
@@ -387,7 +390,7 @@ static int transaction1_oob(struct tdb1_context *tdb, tdb1_off_t len, int probe)
if (len <= tdb->map_size) {
return 0;
}
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = TDB_ERR_IO;
return -1;
}
@@ -425,20 +428,20 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb)
{
/* some sanity checks */
if (tdb->read_only || (tdb->flags & TDB1_INTERNAL) || tdb->traverse_read) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_start: cannot start a transaction on a read-only or internal db\n"));
- tdb->ecode = TDB1_ERR_EINVAL;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_start: cannot start a"
+ " transaction on a read-only or"
+ " internal db");
return -1;
}
/* cope with nested tdb1_transaction_start() calls */
if (tdb->transaction != NULL) {
if (!(tdb->flags & TDB1_ALLOW_NESTING)) {
- tdb->ecode = TDB1_ERR_NESTING;
+ tdb->last_error = TDB_ERR_EINVAL;
return -1;
}
tdb->transaction->nesting++;
- TDB1_LOG((tdb, TDB1_DEBUG_TRACE, "tdb1_transaction_start: nesting %d\n",
- tdb->transaction->nesting));
return 0;
}
@@ -446,8 +449,9 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb)
/* the caller must not have any locks when starting a
transaction as otherwise we'll be screwed by lack
of nested locks in posix */
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_start: cannot start a transaction with locks held\n"));
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_start: cannot start a"
+ " transaction with locks held");
return -1;
}
@@ -455,15 +459,16 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb)
/* you cannot use transactions inside a traverse (although you can use
traverse inside a transaction) as otherwise you can end up with
deadlock */
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_start: cannot start a transaction within a traverse\n"));
- tdb->ecode = TDB1_ERR_LOCK;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_start: cannot start a"
+ " transaction within a traverse");
return -1;
}
tdb->transaction = (struct tdb1_transaction *)
calloc(sizeof(struct tdb1_transaction), 1);
if (tdb->transaction == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
return -1;
}
@@ -482,7 +487,8 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb)
/* get a read lock from the freelist to the end of file. This
is upgraded to a write lock during the commit */
if (tdb1_allrecord_lock(tdb, F_RDLCK, TDB1_LOCK_WAIT, true) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_start: failed to get hash locks\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_start: failed to get hash locks");
goto fail_allrecord_lock;
}
@@ -491,13 +497,13 @@ static int _tdb1_transaction_start(struct tdb1_context *tdb)
tdb->transaction->hash_heads = (uint32_t *)
calloc(tdb->header.hash_size+1, sizeof(uint32_t));
if (tdb->transaction->hash_heads == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
goto fail;
}
if (tdb->methods->tdb1_read(tdb, TDB1_FREELIST_TOP, tdb->transaction->hash_heads,
TDB1_HASHTABLE_SIZE(tdb), 0) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_start: failed to read hash heads\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_start: failed to read hash heads");
goto fail;
}
@@ -542,8 +548,8 @@ static int transaction1_sync(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_l
#else
if (fsync(tdb->fd) != 0) {
#endif
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction: fsync failed\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_transaction: fsync failed");
return -1;
}
#if HAVE_MMAP
@@ -551,9 +557,10 @@ static int transaction1_sync(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_l
tdb1_off_t moffset = offset & ~(tdb->page_size-1);
if (msync(moffset + (char *)tdb->map_ptr,
length + (offset - moffset), MS_SYNC) != 0) {
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction: msync failed - %s\n",
- strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_transaction:"
+ " msync failed - %s",
+ strerror(errno));
return -1;
}
}
@@ -567,7 +574,9 @@ static int _tdb1_transaction_cancel(struct tdb1_context *tdb)
int i, ret = 0;
if (tdb->transaction == NULL) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_cancel: no transaction\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_cancel:"
+ " no transaction");
return -1;
}
@@ -594,7 +603,9 @@ static int _tdb1_transaction_cancel(struct tdb1_context *tdb)
/* remove the recovery marker */
if (methods->tdb1_write(tdb, tdb->transaction->magic_offset, &invalid, 4) == -1 ||
transaction1_sync(tdb, tdb->transaction->magic_offset, 4) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_cancel: failed to remove recovery magic\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_cancel: failed to"
+ " remove recovery magic");
ret = -1;
}
}
@@ -688,7 +699,9 @@ static int tdb1_recovery_allocate(struct tdb1_context *tdb,
tdb1_off_t recovery_head;
if (tdb1_recovery_area(tdb, methods, &recovery_head, &rec) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_recovery_allocate: failed to read recovery head\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_recovery_allocate:"
+ " failed to read recovery head");
return -1;
}
@@ -708,7 +721,9 @@ static int tdb1_recovery_allocate(struct tdb1_context *tdb,
the transaction) */
if (recovery_head != 0) {
if (tdb1_free(tdb, recovery_head, &rec) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_recovery_allocate: failed to free previous recovery area\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_recovery_allocate: failed to free"
+ " previous recovery area");
return -1;
}
}
@@ -724,7 +739,9 @@ static int tdb1_recovery_allocate(struct tdb1_context *tdb,
if (methods->tdb1_expand_file(tdb, tdb->transaction->old_map_size,
(tdb->map_size - tdb->transaction->old_map_size) +
sizeof(rec) + *recovery_max_size) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_recovery_allocate: failed to create recovery area\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_recovery_allocate:"
+ " failed to create recovery area");
return -1;
}
@@ -740,11 +757,15 @@ static int tdb1_recovery_allocate(struct tdb1_context *tdb,
TDB1_CONV(recovery_head);
if (methods->tdb1_write(tdb, TDB1_RECOVERY_HEAD,
&recovery_head, sizeof(tdb1_off_t)) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_recovery_allocate: failed to write recovery head\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_recovery_allocate:"
+ " failed to write recovery head");
return -1;
}
if (transaction1_write_existing(tdb, TDB1_RECOVERY_HEAD, &recovery_head, sizeof(tdb1_off_t)) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_recovery_allocate: failed to write recovery head\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_recovery_allocate:"
+ " failed to write recovery head");
return -1;
}
@@ -777,7 +798,7 @@ static int transaction1_setup_recovery(struct tdb1_context *tdb,
data = (unsigned char *)malloc(recovery_size + sizeof(*rec));
if (data == NULL) {
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = TDB_ERR_OOM;
return -1;
}
@@ -811,9 +832,10 @@ static int transaction1_setup_recovery(struct tdb1_context *tdb,
continue;
}
if (offset + length > tdb->transaction->old_map_size) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_setup_recovery: transaction data over new region boundary\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
+ TDB_LOG_ERROR,
+ "tdb1_transaction_setup_recovery: transaction data over new region boundary");
free(data);
- tdb->ecode = TDB1_ERR_CORRUPT;
return -1;
}
memcpy(p, &offset, 4);
@@ -826,7 +848,7 @@ static int transaction1_setup_recovery(struct tdb1_context *tdb,
method to get it */
if (methods->tdb1_read(tdb, offset, p + 8, length, 0) != 0) {
free(data);
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = TDB_ERR_IO;
return -1;
}
p += 8 + length;
@@ -841,15 +863,17 @@ static int transaction1_setup_recovery(struct tdb1_context *tdb,
/* write the recovery data to the recovery area */
if (methods->tdb1_write(tdb, recovery_offset, data, sizeof(*rec) + recovery_size) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_setup_recovery: failed to write recovery data\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_setup_recovery:"
+ " failed to write recovery data");
free(data);
- tdb->ecode = TDB1_ERR_IO;
return -1;
}
if (transaction1_write_existing(tdb, recovery_offset, data, sizeof(*rec) + recovery_size) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_setup_recovery: failed to write secondary recovery data\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_setup_recovery: failed to write"
+ " secondary recovery data");
free(data);
- tdb->ecode = TDB1_ERR_IO;
return -1;
}
@@ -869,13 +893,15 @@ static int transaction1_setup_recovery(struct tdb1_context *tdb,
*magic_offset = recovery_offset + offsetof(struct tdb1_record, magic);
if (methods->tdb1_write(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_setup_recovery: failed to write recovery magic\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_setup_recovery:"
+ " failed to write recovery magic");
return -1;
}
if (transaction1_write_existing(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_setup_recovery: failed to write secondary recovery magic\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_setup_recovery:"
+ " failed to write secondary recovery magic");
return -1;
}
@@ -892,21 +918,25 @@ static int _tdb1_transaction_prepare_commit(struct tdb1_context *tdb)
const struct tdb1_methods *methods;
if (tdb->transaction == NULL) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: no transaction\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " no transaction");
return -1;
}
if (tdb->transaction->prepared) {
- tdb->ecode = TDB1_ERR_EINVAL;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " transaction already prepared");
_tdb1_transaction_cancel(tdb);
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: transaction already prepared\n"));
return -1;
}
if (tdb->transaction->transaction_error) {
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " transaction error pending");
_tdb1_transaction_cancel(tdb);
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: transaction error pending\n"));
return -1;
}
@@ -925,15 +955,18 @@ static int _tdb1_transaction_prepare_commit(struct tdb1_context *tdb)
/* if there are any locks pending then the caller has not
nested their locks properly, so fail the transaction */
if (tdb1_have_extra_locks(tdb)) {
- tdb->ecode = TDB1_ERR_LOCK;
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: locks pending on commit\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " locks pending on commit");
_tdb1_transaction_cancel(tdb);
return -1;
}
/* upgrade the main transaction lock region to a write lock */
if (tdb1_allrecord_upgrade(tdb) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: failed to upgrade hash locks\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " failed to upgrade hash locks");
_tdb1_transaction_cancel(tdb);
return -1;
}
@@ -941,7 +974,9 @@ static int _tdb1_transaction_prepare_commit(struct tdb1_context *tdb)
/* get the open lock - this prevents new users attaching to the database
during the commit */
if (tdb1_nest_lock(tdb, TDB1_OPEN_LOCK, F_WRLCK, TDB1_LOCK_WAIT) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_prepare_commit: failed to get open lock\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " failed to get open lock");
_tdb1_transaction_cancel(tdb);
return -1;
}
@@ -949,7 +984,9 @@ static int _tdb1_transaction_prepare_commit(struct tdb1_context *tdb)
if (!(tdb->flags & TDB1_NOSYNC)) {
/* write the recovery data to the end of the file */
if (transaction1_setup_recovery(tdb, &tdb->transaction->magic_offset) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_prepare_commit: failed to setup recovery data\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " failed to setup recovery data");
_tdb1_transaction_cancel(tdb);
return -1;
}
@@ -962,8 +999,9 @@ static int _tdb1_transaction_prepare_commit(struct tdb1_context *tdb)
if (methods->tdb1_expand_file(tdb, tdb->transaction->old_map_size,
tdb->map_size -
tdb->transaction->old_map_size) == -1) {
- tdb->ecode = TDB1_ERR_IO;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_prepare_commit: expansion failed\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_prepare_commit:"
+ " expansion failed");
_tdb1_transaction_cancel(tdb);
return -1;
}
@@ -1016,14 +1054,17 @@ int tdb1_transaction_commit(struct tdb1_context *tdb)
bool need_repack = false;
if (tdb->transaction == NULL) {
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_commit: no transaction\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
+ "tdb1_transaction_commit:"
+ " no transaction");
return -1;
}
if (tdb->transaction->transaction_error) {
- tdb->ecode = TDB1_ERR_IO;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_transaction_commit:"
+ " transaction error pending");
_tdb1_transaction_cancel(tdb);
- TDB1_LOG((tdb, TDB1_DEBUG_ERROR, "tdb1_transaction_commit: transaction error pending\n"));
return -1;
}
@@ -1063,7 +1104,9 @@ int tdb1_transaction_commit(struct tdb1_context *tdb)
}
if (methods->tdb1_write(tdb, offset, tdb->transaction->blocks[i], length) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_commit: write failed during commit\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_commit:"
+ " write failed during commit");
/* we've overwritten part of the data and
possibly expanded the file, so we need to
@@ -1073,7 +1116,8 @@ int tdb1_transaction_commit(struct tdb1_context *tdb)
_tdb1_transaction_cancel(tdb);
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_commit: write failed\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_commit: write failed");
return -1;
}
SAFE_FREE(tdb->transaction->blocks[i]);
@@ -1133,8 +1177,9 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
/* find the recovery area */
if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to read recovery head\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " failed to read recovery head");
return -1;
}
@@ -1146,8 +1191,9 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
/* read the recovery record */
if (tdb->methods->tdb1_read(tdb, recovery_head, &rec,
sizeof(rec), TDB1_DOCONV()) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to read recovery record\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " failed to read recovery record");
return -1;
}
@@ -1157,8 +1203,10 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
}
if (tdb->read_only) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: attempt to recover read only database\n"));
- tdb->ecode = TDB1_ERR_CORRUPT;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " attempt to recover read only"
+ " database");
return -1;
}
@@ -1166,16 +1214,18 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
data = (unsigned char *)malloc(rec.data_len);
if (data == NULL) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to allocate recovery data\n"));
- tdb->ecode = TDB1_ERR_OOM;
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " failed to allocate recovery data");
return -1;
}
/* read the full recovery data */
if (tdb->methods->tdb1_read(tdb, recovery_head + sizeof(rec), data,
rec.data_len, 0) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to read recovery data\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " failed to read recovery data");
return -1;
}
@@ -1191,8 +1241,9 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
if (tdb->methods->tdb1_write(tdb, ofs, p+8, len) == -1) {
free(data);
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to recover %d bytes at offset %d\n", len, ofs));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover: failed to recover"
+ " %d bytes at offset %d", len, ofs);
return -1;
}
p += 8 + len;
@@ -1201,16 +1252,17 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
free(data);
if (transaction1_sync(tdb, 0, tdb->map_size) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to sync recovery\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover: failed to sync recovery");
return -1;
}
/* if the recovery area is after the recovered eof then remove it */
if (recovery_eof <= recovery_head) {
if (tdb1_ofs_write(tdb, TDB1_RECOVERY_HEAD, &zero) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to remove recovery head\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover: failed to remove"
+ " recovery head");
return -1;
}
}
@@ -1218,19 +1270,22 @@ int tdb1_transaction_recover(struct tdb1_context *tdb)
/* remove the recovery magic */
if (tdb1_ofs_write(tdb, recovery_head + offsetof(struct tdb1_record, magic),
&zero) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to remove recovery magic\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover: failed to remove"
+ " recovery magic");
return -1;
}
if (transaction1_sync(tdb, 0, recovery_eof) == -1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_transaction_recover: failed to sync2 recovery\n"));
- tdb->ecode = TDB1_ERR_IO;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_transaction_recover:"
+ " failed to sync2 recovery");
return -1;
}
- TDB1_LOG((tdb, TDB1_DEBUG_TRACE, "tdb1_transaction_recover: recovered %d byte database\n",
- recovery_eof));
+ tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
+ "tdb1_transaction_recover: recovered %d byte database",
+ recovery_eof);
/* all done */
return 0;
diff --git a/lib/tdb2/tdb1_traverse.c b/lib/tdb2/tdb1_traverse.c
index ba1501279d..13813eebbb 100644
--- a/lib/tdb2/tdb1_traverse.c
+++ b/lib/tdb2/tdb1_traverse.c
@@ -102,8 +102,10 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
/* Detect infinite loops. From "Shlomi Yaakobovich" <Shlomi@exanet.com>. */
if (tlock->off == rec->next) {
- tdb->ecode = TDB1_ERR_CORRUPT;
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_next_lock: loop detected.\n"));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
+ TDB_LOG_ERROR,
+ "tdb1_next_lock:"
+ " loop detected.");
goto fail;
}
@@ -125,13 +127,14 @@ static tdb1_off_t tdb1_next_lock(struct tdb1_context *tdb, struct tdb1_traverse_
want_next = 0;
}
/* We finished iteration without finding anything */
- tdb->ecode = TDB1_SUCCESS;
+ tdb->last_error = TDB_SUCCESS;
return 0;
fail:
tlock->off = 0;
if (tdb1_unlock(tdb, tlock->hash, tlock->lock_rw) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_next_lock: On error unlock failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_next_lock: On error unlock failed!");
return TDB1_NEXT_LOCK_ERR;
}
@@ -172,7 +175,9 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
if (tdb1_unlock(tdb, tl->hash, tl->lock_rw) != 0)
goto out;
if (tdb1_unlock_record(tdb, tl->off) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_traverse: key.dptr == NULL and unlock_record failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_traverse: key.dptr == NULL and"
+ " unlock_record failed!");
goto out;
}
key.dsize = rec.key_len;
@@ -188,7 +193,9 @@ static int tdb1_traverse_internal(struct tdb1_context *tdb,
if (fn && fn(tdb, key, dbuf, private_data)) {
/* They want us to terminate traversal */
if (tdb1_unlock_record(tdb, tl->off) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_traverse: unlock_record failed!\n"));;
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_traverse:"
+ " unlock_record failed!");
ret = -1;
}
SAFE_FREE(key.dptr);
@@ -284,7 +291,9 @@ TDB1_DATA tdb1_firstkey(struct tdb1_context *tdb)
/* Unlock the hash chain of the record we just read. */
if (tdb1_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_firstkey: error occurred while tdb1_unlocking!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_firstkey:"
+ " error occurred while tdb1_unlocking!");
return key;
}
@@ -328,7 +337,9 @@ TDB1_DATA tdb1_nextkey(struct tdb1_context *tdb, TDB1_DATA oldkey)
}
tdb->travlocks.hash = TDB1_BUCKET(rec.full_hash);
if (tdb1_lock_record(tdb, tdb->travlocks.off) != 0) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: lock_record failed (%s)!\n", strerror(errno)));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_nextkey: lock_record failed (%s)!",
+ strerror(errno));
return tdb1_null;
}
}
@@ -343,10 +354,12 @@ TDB1_DATA tdb1_nextkey(struct tdb1_context *tdb, TDB1_DATA oldkey)
key.dsize);
/* Unlock the chain of this new record */
if (tdb1_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: WARNING tdb1_unlock failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_nextkey: WARNING tdb1_unlock failed!");
}
/* Unlock the chain of old record */
if (tdb1_unlock(tdb, TDB1_BUCKET(oldhash), tdb->travlocks.lock_rw) != 0)
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "tdb1_nextkey: WARNING tdb1_unlock failed!\n"));
+ tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
+ "tdb1_nextkey: WARNING tdb1_unlock failed!");
return key;
}
diff --git a/lib/tdb2/test/run-tdb1-3G-file.c b/lib/tdb2/test/run-tdb1-3G-file.c
index 6509ca3ab7..fd66c047b1 100644
--- a/lib/tdb2/test/run-tdb1-3G-file.c
+++ b/lib/tdb2/test/run-tdb1-3G-file.c
@@ -11,7 +11,7 @@ static int tdb1_expand_file_sparse(struct tdb1_context *tdb,
tdb1_off_t addition)
{
if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB1_ERR_RDONLY;
+ tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
@@ -27,8 +27,10 @@ static int tdb1_expand_file_sparse(struct tdb1_context *tdb,
errno = ENOSPC;
}
if (written != 1) {
- TDB1_LOG((tdb, TDB1_DEBUG_FATAL, "expand_file to %d failed (%s)\n",
- size+addition, strerror(errno)));
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "expand_file to %d failed (%s)",
+ size+addition,
+ strerror(errno));
return -1;
}
}
diff --git a/lib/tdb2/test/run-tdb1-check.c b/lib/tdb2/test/run-tdb1-check.c
index 03b0191a17..b3b240e002 100644
--- a/lib/tdb2/test/run-tdb1-check.c
+++ b/lib/tdb2/test/run-tdb1-check.c
@@ -35,7 +35,7 @@ int main(int argc, char *argv[])
&taplogctx, NULL);
ok1(tdb);
ok1(tdb1_check(tdb, NULL, NULL) == -1);
- ok1(tdb1_error(tdb) == TDB1_ERR_CORRUPT);
+ ok1(tdb_error(tdb) == TDB_ERR_CORRUPT);
tdb1_close(tdb);
/* Big and little endian should work! */
diff --git a/lib/tdb2/test/run-tdb1-endian.c b/lib/tdb2/test/run-tdb1-endian.c
index 1a01de17ab..7691260606 100644
--- a/lib/tdb2/test/run-tdb1-endian.c
+++ b/lib/tdb2/test/run-tdb1-endian.c
@@ -21,10 +21,10 @@ int main(int argc, char *argv[])
data.dptr = (void *)"world";
ok1(tdb1_store(tdb, key, data, TDB1_MODIFY) < 0);
- ok1(tdb1_error(tdb) == TDB1_ERR_NOEXIST);
+ ok1(tdb_error(tdb) == TDB_ERR_NOEXIST);
ok1(tdb1_store(tdb, key, data, TDB1_INSERT) == 0);
ok1(tdb1_store(tdb, key, data, TDB1_INSERT) < 0);
- ok1(tdb1_error(tdb) == TDB1_ERR_EXISTS);
+ ok1(tdb_error(tdb) == TDB_ERR_EXISTS);
ok1(tdb1_store(tdb, key, data, TDB1_MODIFY) == 0);
data = tdb1_fetch(tdb, key);
diff --git a/lib/tdb2/test/run-tdb1-incompatible.c b/lib/tdb2/test/run-tdb1-incompatible.c
index 5a4a61af33..13ba810169 100644
--- a/lib/tdb2/test/run-tdb1-incompatible.c
+++ b/lib/tdb2/test/run-tdb1-incompatible.c
@@ -8,10 +8,11 @@ static unsigned int tdb1_dumb_hash(TDB1_DATA *key)
return key->dsize;
}
-static void log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...)
+static void log_fn(struct tdb1_context *tdb, enum tdb_log_level level,
+ enum TDB_ERROR ecode, const char *message, void *priv)
{
- unsigned int *count = tdb->log.log_private;
- if (strstr(fmt, "hash"))
+ unsigned int *count = priv;
+ if (strstr(message, "hash"))
(*count)++;
}
diff --git a/lib/tdb2/test/run-tdb1-nested-transactions.c b/lib/tdb2/test/run-tdb1-nested-transactions.c
index 2518003c63..e9640990e0 100644
--- a/lib/tdb2/test/run-tdb1-nested-transactions.c
+++ b/lib/tdb2/test/run-tdb1-nested-transactions.c
@@ -28,7 +28,7 @@ int main(int argc, char *argv[])
ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
free(data.dptr);
ok1(tdb1_transaction_start(tdb) != 0);
- ok1(tdb1_error(tdb) == TDB1_ERR_NESTING);
+ ok1(tdb_error(tdb) == TDB_ERR_EINVAL);
data = tdb1_fetch(tdb, key);
ok1(data.dsize == strlen("world"));
diff --git a/lib/tdb2/test/run-tdb1-readonly-check.c b/lib/tdb2/test/run-tdb1-readonly-check.c
index 2c06ca92ee..6bfa0dc3f5 100644
--- a/lib/tdb2/test/run-tdb1-readonly-check.c
+++ b/lib/tdb2/test/run-tdb1-readonly-check.c
@@ -35,7 +35,7 @@ int main(int argc, char *argv[])
ok1(tdb);
ok1(tdb1_store(tdb, key, data, TDB1_MODIFY) == -1);
- ok1(tdb1_error(tdb) == TDB1_ERR_RDONLY);
+ ok1(tdb_error(tdb) == TDB_ERR_RDONLY);
ok1(tdb1_check(tdb, NULL, NULL) == 0);
ok1(tdb1_close(tdb) == 0);
diff --git a/lib/tdb2/test/run-tdb1-rwlock-check.c b/lib/tdb2/test/run-tdb1-rwlock-check.c
index f40a6fe13e..ec2a66a5bf 100644
--- a/lib/tdb2/test/run-tdb1-rwlock-check.c
+++ b/lib/tdb2/test/run-tdb1-rwlock-check.c
@@ -3,10 +3,11 @@
#include <stdlib.h>
#include <err.h>
-static void log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...)
+static void log_fn(struct tdb1_context *tdb, enum tdb_log_level level,
+ enum TDB_ERROR ecode, const char *message, void *priv)
{
- unsigned int *count = tdb->log.log_private;
- if (strstr(fmt, "spinlocks"))
+ unsigned int *count = priv;
+ if (strstr(message, "spinlocks"))
(*count)++;
}
diff --git a/lib/tdb2/test/run-tdb1-wronghash-fail.c b/lib/tdb2/test/run-tdb1-wronghash-fail.c
index 15047677a2..59bfbbeccb 100644
--- a/lib/tdb2/test/run-tdb1-wronghash-fail.c
+++ b/lib/tdb2/test/run-tdb1-wronghash-fail.c
@@ -3,10 +3,11 @@
#include <stdlib.h>
#include <err.h>
-static void log_fn(struct tdb1_context *tdb, enum tdb1_debug_level level, const char *fmt, ...)
+static void log_fn(struct tdb1_context *tdb, enum tdb_log_level level,
+ enum TDB_ERROR ecode, const char *message, void *priv)
{
- unsigned int *count = tdb->log.log_private;
- if (strstr(fmt, "hash"))
+ unsigned int *count = priv;
+ if (strstr(message, "hash"))
(*count)++;
}
diff --git a/lib/tdb2/test/run-tdb1.c b/lib/tdb2/test/run-tdb1.c
index ebbfd77bb2..30de924cd2 100644
--- a/lib/tdb2/test/run-tdb1.c
+++ b/lib/tdb2/test/run-tdb1.c
@@ -20,10 +20,10 @@ int main(int argc, char *argv[])
data.dptr = (void *)"world";
ok1(tdb1_store(tdb, key, data, TDB1_MODIFY) < 0);
- ok1(tdb1_error(tdb) == TDB1_ERR_NOEXIST);
+ ok1(tdb_error(tdb) == TDB_ERR_NOEXIST);
ok1(tdb1_store(tdb, key, data, TDB1_INSERT) == 0);
ok1(tdb1_store(tdb, key, data, TDB1_INSERT) < 0);
- ok1(tdb1_error(tdb) == TDB1_ERR_EXISTS);
+ ok1(tdb_error(tdb) == TDB_ERR_EXISTS);
ok1(tdb1_store(tdb, key, data, TDB1_MODIFY) == 0);
data = tdb1_fetch(tdb, key);
diff --git a/lib/tdb2/test/tdb1-external-agent.c b/lib/tdb2/test/tdb1-external-agent.c
index da9d709468..7ccbd9ca37 100644
--- a/lib/tdb2/test/tdb1-external-agent.c
+++ b/lib/tdb2/test/tdb1-external-agent.c
@@ -61,7 +61,7 @@ static enum agent_return do_operation(enum operation op, const char *name)
case FETCH:
data = tdb1_fetch(tdb, k);
if (data.dptr == NULL) {
- if (tdb->ecode == TDB1_ERR_NOEXIST)
+ if (tdb->last_error == TDB_ERR_NOEXIST)
ret = FAILED;
else
ret = OTHER_FAILURE;
diff --git a/lib/tdb2/test/tdb1-logging.c b/lib/tdb2/test/tdb1-logging.c
index 43ce07b27c..3424296b91 100644
--- a/lib/tdb2/test/tdb1-logging.c
+++ b/lib/tdb2/test/tdb1-logging.c
@@ -7,24 +7,19 @@
/* Turn log messages into tap diag messages. */
static void taplog(struct tdb1_context *tdb,
- enum tdb1_debug_level level,
- const char *fmt, ...)
+ enum tdb_log_level level,
+ enum TDB_ERROR ecode,
+ const char *message,
+ void *data)
{
- va_list ap;
- char line[200];
-
if (suppress_logging)
return;
- va_start(ap, fmt);
- vsprintf(line, fmt, ap);
- va_end(ap);
-
/* Strip trailing \n: diag adds it. */
- if (line[0] && line[strlen(line)-1] == '\n')
- diag("%s%.*s", log_prefix, (unsigned)strlen(line)-1, line);
+ if (message[0] && message[strlen(message)-1] == '\n')
+ diag("%s%.*s", log_prefix, (unsigned)strlen(message)-1, message);
else
- diag("%s%s", log_prefix, line);
+ diag("%s%s", log_prefix, message);
}
struct tdb1_logging_context taplogctx = { taplog, NULL };