This rips out all the TDB1 compatibility from tdb2.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
--- /dev/null
+tdb_add_flag: void (struct tdb_context *, unsigned int)
+tdb_append: enum TDB_ERROR (struct tdb_context *, struct tdb_data, struct tdb_data)
+tdb_chainlock: enum TDB_ERROR (struct tdb_context *, TDB_DATA)
+tdb_chainlock_read: enum TDB_ERROR (struct tdb_context *, TDB_DATA)
+tdb_chainunlock: void (struct tdb_context *, TDB_DATA)
+tdb_chainunlock_read: void (struct tdb_context *, TDB_DATA)
+tdb_check_: enum TDB_ERROR (struct tdb_context *, enum TDB_ERROR (*)(TDB_DATA, TDB_DATA, void *), void *)
+tdb_close: int (struct tdb_context *)
+tdb_delete: enum TDB_ERROR (struct tdb_context *, struct tdb_data)
+tdb_error: enum TDB_ERROR (struct tdb_context *)
+tdb_errorstr: const char *(enum TDB_ERROR)
+tdb_exists: bool (struct tdb_context *, TDB_DATA)
+tdb_fd: int (const struct tdb_context *)
+tdb_fetch: enum TDB_ERROR (struct tdb_context *, struct tdb_data, struct tdb_data *)
+tdb_firstkey: enum TDB_ERROR (struct tdb_context *, struct tdb_data *)
+tdb_foreach_: void (int (*)(struct tdb_context *, void *), void *)
+tdb_get_attribute: enum TDB_ERROR (struct tdb_context *, union tdb_attribute *)
+tdb_get_flags: unsigned int (struct tdb_context *)
+tdb_get_seqnum: int64_t (struct tdb_context *)
+tdb_lockall: enum TDB_ERROR (struct tdb_context *)
+tdb_lockall_read: enum TDB_ERROR (struct tdb_context *)
+tdb_name: const char *(const struct tdb_context *)
+tdb_nextkey: enum TDB_ERROR (struct tdb_context *, struct tdb_data *)
+tdb_open: struct tdb_context *(const char *, int, int, mode_t, union tdb_attribute *)
+tdb_parse_record_: enum TDB_ERROR (struct tdb_context *, TDB_DATA, enum TDB_ERROR (*)(TDB_DATA, TDB_DATA, void *), void *)
+tdb_remove_flag: void (struct tdb_context *, unsigned int)
+tdb_repack: enum TDB_ERROR (struct tdb_context *)
+tdb_set_attribute: enum TDB_ERROR (struct tdb_context *, const union tdb_attribute *)
+tdb_store: enum TDB_ERROR (struct tdb_context *, struct tdb_data, struct tdb_data, int)
+tdb_summary: enum TDB_ERROR (struct tdb_context *, enum tdb_summary_flags, char **)
+tdb_transaction_cancel: void (struct tdb_context *)
+tdb_transaction_commit: enum TDB_ERROR (struct tdb_context *)
+tdb_transaction_prepare_commit: enum TDB_ERROR (struct tdb_context *)
+tdb_transaction_start: enum TDB_ERROR (struct tdb_context *)
+tdb_traverse_: int64_t (struct tdb_context *, int (*)(struct tdb_context *, TDB_DATA, TDB_DATA, void *), void *)
+tdb_unlockall: void (struct tdb_context *)
+tdb_unlockall_read: void (struct tdb_context *)
+tdb_unset_attribute: void (struct tdb_context *, enum tdb_attribute_type)
+tdb_wipe_all: enum TDB_ERROR (struct tdb_context *)
" cannot check.");
}
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_check(tdb, check, data) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
if (ecode != TDB_SUCCESS) {
return tdb->last_error = ecode;
contention - it cannot guarantee how many records will be locked */
_PUBLIC_ enum TDB_ERROR tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
{
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_chainlock(tdb, key) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
return tdb->last_error = chainlock(tdb, &key, F_WRLCK, TDB_LOCK_WAIT,
"tdb_chainlock");
}
tdb_off_t lockstart, locksize;
unsigned int group, gbits;
- if (tdb->flags & TDB_VERSION1) {
- tdb1_chainunlock(tdb, key);
- return;
- }
-
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits);
_PUBLIC_ enum TDB_ERROR tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
{
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_chainlock_read(tdb, key) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
return tdb->last_error = chainlock(tdb, &key, F_RDLCK, TDB_LOCK_WAIT,
"tdb_chainlock_read");
}
tdb_off_t lockstart, locksize;
unsigned int group, gbits;
- if (tdb->flags & TDB_VERSION1) {
- tdb1_chainunlock_read(tdb, key);
- return;
- }
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits);
{
tdb_off_t seq;
- if (tdb->flags & TDB_VERSION1) {
- tdb1_increment_seqnum_nonblock(tdb);
- return;
- }
-
if (likely(!(tdb->flags & TDB_CONVERT))) {
int64_t *direct;
struct tdb_lock *new_lck;
enum TDB_ERROR ecode;
- if (!(tdb->flags & TDB_VERSION1)
- && offset > (TDB_HASH_LOCK_START + TDB_HASH_LOCK_RANGE
- + tdb->file->map_size / 8)) {
+ if (offset > (TDB_HASH_LOCK_START + TDB_HASH_LOCK_RANGE
+ + tdb->file->map_size / 8)) {
return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
"tdb_nest_lock: invalid offset %zu ltype=%d",
(size_t)offset, ltype);
enum TDB_ERROR ecode;
tdb_bool_err berr;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_allrecord_lock(tdb, ltype, flags, upgradable) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
if (tdb->flags & TDB_NOLOCK)
return TDB_SUCCESS;
/* unlock entire db */
void tdb_allrecord_unlock(struct tdb_context *tdb, int ltype)
{
- if (tdb->flags & TDB_VERSION1) {
- tdb1_allrecord_unlock(tdb, ltype);
- return;
- }
-
if (tdb->flags & TDB_NOLOCK)
return;
case TDB_ATTRIBUTE_HASH:
case TDB_ATTRIBUTE_SEED:
case TDB_ATTRIBUTE_OPENHOOK:
- case TDB_ATTRIBUTE_TDB1_HASHSIZE:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
TDB_LOG_USE_ERROR,
? "TDB_ATTRIBUTE_HASH"
: attr->base.attr == TDB_ATTRIBUTE_SEED
? "TDB_ATTRIBUTE_SEED"
- : attr->base.attr == TDB_ATTRIBUTE_OPENHOOK
- ? "TDB_ATTRIBUTE_OPENHOOK"
- : "TDB_ATTRIBUTE_TDB1_HASHSIZE");
+ : "TDB_ATTRIBUTE_OPENHOOK");
case TDB_ATTRIBUTE_STATS:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
attr->hash.data = tdb->hash_data;
break;
case TDB_ATTRIBUTE_SEED:
- if (tdb->flags & TDB_VERSION1)
- return tdb->last_error
- = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb_get_attribute:"
- " cannot get TDB_ATTRIBUTE_SEED"
- " on TDB1 tdb.");
attr->seed.seed = tdb->hash_seed;
break;
case TDB_ATTRIBUTE_OPENHOOK:
attr->flock.unlock = tdb->unlock_fn;
attr->flock.data = tdb->lock_data;
break;
- case TDB_ATTRIBUTE_TDB1_HASHSIZE:
- if (!(tdb->flags & TDB_VERSION1))
- return tdb->last_error
- = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb_get_attribute:"
- " cannot get TDB_ATTRIBUTE_TDB1_HASHSIZE"
- " on TDB2 tdb.");
- attr->tdb1_hashsize.hsize = tdb->tdb1.header.hash_size;
- break;
default:
return tdb->last_error
= tdb_logerr(tdb, TDB_ERR_EINVAL,
break;
case TDB_ATTRIBUTE_HASH:
case TDB_ATTRIBUTE_SEED:
- case TDB_ATTRIBUTE_TDB1_HASHSIZE:
tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
"tdb_unset_attribute: cannot unset %s after opening",
type == TDB_ATTRIBUTE_HASH
? "TDB_ATTRIBUTE_HASH"
- : type == TDB_ATTRIBUTE_SEED
- ? "TDB_ATTRIBUTE_SEED"
- : "TDB_ATTRIBUTE_TDB1_HASHSIZE");
+ : "TDB_ATTRIBUTE_SEED");
break;
case TDB_ATTRIBUTE_STATS:
tdb_logerr(tdb, TDB_ERR_EINVAL,
}
}
-static bool is_tdb1(struct tdb1_header *hdr, const void *buf, ssize_t rlen)
-{
- /* This code assumes we've tried to read entire tdb1 header. */
- BUILD_ASSERT(sizeof(*hdr) <= sizeof(struct tdb_header));
-
- if (rlen < (ssize_t)sizeof(*hdr)) {
- return false;
- }
-
- memcpy(hdr, buf, sizeof(*hdr));
- if (strcmp(hdr->magic_food, TDB_MAGIC_FOOD) != 0)
- return false;
-
- return hdr->version == TDB1_VERSION
- || hdr->version == TDB1_BYTEREV(TDB1_VERSION);
-}
-
/* The top three bits of the capability tell us whether it matters. */
enum TDB_ERROR unknown_capability(struct tdb_context *tdb, const char *caller,
tdb_off_t type)
ssize_t rlen;
struct tdb_header hdr;
struct tdb_attribute_seed *seed = NULL;
- struct tdb_attribute_tdb1_hashsize *hsize_attr = NULL;
- struct tdb_attribute_tdb1_max_dead *maxsize_attr = NULL;
tdb_bool_err berr;
enum TDB_ERROR ecode;
int openlock;
tdb->openhook = attr->openhook.fn;
tdb->openhook_data = attr->openhook.data;
break;
- case TDB_ATTRIBUTE_TDB1_HASHSIZE:
- hsize_attr = &attr->tdb1_hashsize;
- break;
- case TDB_ATTRIBUTE_TDB1_MAX_DEAD:
- maxsize_attr = &attr->tdb1_max_dead;
- break;
default:
/* These are set as normal. */
ecode = tdb_set_attribute(tdb, attr);
if (tdb_flags & ~(TDB_INTERNAL | TDB_NOLOCK | TDB_NOMMAP | TDB_CONVERT
| TDB_NOSYNC | TDB_SEQNUM | TDB_ALLOW_NESTING
- | TDB_RDONLY | TDB_VERSION1)) {
+ | TDB_RDONLY)) {
ecode = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
"tdb_open: unknown flags %u", tdb_flags);
goto fail;
}
- if (hsize_attr) {
- if (!(tdb_flags & TDB_VERSION1) ||
- (!(tdb_flags & TDB_INTERNAL) && !(open_flags & O_CREAT))) {
- ecode = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb_open: can only use"
- " TDB_ATTRIBUTE_TDB1_HASHSIZE when"
- " creating a TDB_VERSION1 tdb");
- goto fail;
- }
- }
-
if (seed) {
- if (tdb_flags & TDB_VERSION1) {
- ecode = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb_open:"
- " cannot set TDB_ATTRIBUTE_SEED"
- " on TDB1 tdb.");
- goto fail;
- } else if (!(tdb_flags & TDB_INTERNAL)
- && !(open_flags & O_CREAT)) {
+ if (!(tdb_flags & TDB_INTERNAL) && !(open_flags & O_CREAT)) {
ecode = tdb_logerr(tdb, TDB_ERR_EINVAL,
TDB_LOG_USE_ERROR,
"tdb_open:"
goto fail;
}
tdb->file->fd = -1;
- if (tdb->flags & TDB_VERSION1)
- ecode = tdb1_new_database(tdb, hsize_attr, maxsize_attr);
- else {
- ecode = tdb_new_database(tdb, seed, &hdr);
- if (ecode == TDB_SUCCESS) {
- tdb_convert(tdb, &hdr.hash_seed,
- sizeof(hdr.hash_seed));
- tdb->hash_seed = hdr.hash_seed;
- tdb2_context_init(tdb);
- tdb_ftable_init(tdb);
- }
+ ecode = tdb_new_database(tdb, seed, &hdr);
+ if (ecode == TDB_SUCCESS) {
+ tdb_convert(tdb, &hdr.hash_seed,
+ sizeof(hdr.hash_seed));
+ tdb->hash_seed = hdr.hash_seed;
+ tdb2_context_init(tdb);
+ tdb_ftable_init(tdb);
}
if (ecode != TDB_SUCCESS) {
goto fail;
/* If they used O_TRUNC, read will return 0. */
rlen = pread(tdb->file->fd, &hdr, sizeof(hdr), 0);
if (rlen == 0 && (open_flags & O_CREAT)) {
- if (tdb->flags & TDB_VERSION1) {
- ecode = tdb1_new_database(tdb, hsize_attr, maxsize_attr);
- if (ecode != TDB_SUCCESS)
- goto fail;
- goto finished;
- }
ecode = tdb_new_database(tdb, seed, &hdr);
if (ecode != TDB_SUCCESS) {
goto fail;
goto fail;
} else if (rlen < sizeof(hdr)
|| strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0) {
- if (is_tdb1(&tdb->tdb1.header, &hdr, rlen)) {
- ecode = tdb1_open(tdb, maxsize_attr);
- if (!ecode)
- goto finished;
- goto fail;
- }
ecode = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb_open: %s is not a tdb file", name);
+ "tdb_open: %s is not a tdb2 file", name);
goto fail;
}
if (hdr.version == bswap_64(TDB_VERSION))
tdb->flags |= TDB_CONVERT;
else {
- if (is_tdb1(&tdb->tdb1.header, &hdr, rlen)) {
- ecode = tdb1_open(tdb, maxsize_attr);
- if (!ecode)
- goto finished;
- goto fail;
- }
/* wrong version */
ecode = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
"tdb_open:"
goto fail;
}
- /* This is a version2 tdb. */
- if (tdb->flags & TDB_VERSION1) {
- tdb->flags &= ~TDB_VERSION1;
- }
-
tdb2_context_init(tdb);
tdb_convert(tdb, &hdr, sizeof(hdr));
goto fail;
}
-finished:
- if (tdb->flags & TDB_VERSION1) {
- /* if needed, run recovery */
- if (tdb1_transaction_recover(tdb) == -1) {
- ecode = tdb->last_error;
- goto fail;
- }
- }
-
tdb_unlock_open(tdb, openlock);
/* This makes sure we have current map_size and mmap. */
- if (tdb->flags & TDB_VERSION1) {
- ecode = tdb1_probe_length(tdb);
- } else {
- ecode = tdb->tdb2.io->oob(tdb, tdb->file->map_size, 1, true);
- }
+ ecode = tdb->tdb2.io->oob(tdb, tdb->file->map_size, 1, true);
if (unlikely(ecode != TDB_SUCCESS))
goto fail;
- if (!(tdb->flags & TDB_VERSION1)) {
- /* Now it's fully formed, recover if necessary. */
- berr = tdb_needs_recovery(tdb);
- if (unlikely(berr != false)) {
- if (berr < 0) {
- ecode = TDB_OFF_TO_ERR(berr);
- goto fail;
- }
- ecode = tdb_lock_and_recover(tdb);
- if (ecode != TDB_SUCCESS) {
- goto fail;
- }
+ /* Now it's fully formed, recover if necessary. */
+ berr = tdb_needs_recovery(tdb);
+ if (unlikely(berr != false)) {
+ if (berr < 0) {
+ ecode = TDB_OFF_TO_ERR(berr);
+ goto fail;
}
-
- ecode = tdb_ftable_init(tdb);
+ ecode = tdb_lock_and_recover(tdb);
if (ecode != TDB_SUCCESS) {
goto fail;
}
}
+ ecode = tdb_ftable_init(tdb);
+ if (ecode != TDB_SUCCESS) {
+ goto fail;
+ }
+
tdb->next = tdbs;
tdbs = tdb;
return tdb;
tdb_trace(tdb, "tdb_close");
- if (tdb->flags & TDB_VERSION1) {
- if (tdb->tdb1.transaction) {
- tdb1_transaction_cancel(tdb);
- }
- } else {
- if (tdb->tdb2.transaction) {
- tdb_transaction_cancel(tdb);
- }
+ if (tdb->tdb2.transaction) {
+ tdb_transaction_cancel(tdb);
}
if (tdb->file->map_ptr) {
#define TDB_MAGIC_FOOD "TDB file\n"
#define TDB_VERSION ((uint64_t)(0x26011967 + 7))
-#define TDB1_VERSION (0x26011967 + 6)
#define TDB_USED_MAGIC ((uint64_t)0x1999)
#define TDB_HTABLE_MAGIC ((uint64_t)0x1888)
#define TDB_CHAIN_MAGIC ((uint64_t)0x1777)
tdb_off_t prev;
};
-typedef uint32_t tdb1_len_t;
-typedef uint32_t tdb1_off_t;
-
enum tdb_lock_flags {
/* WAIT == F_SETLKW, NOWAIT == F_SETLK */
TDB_LOCK_NOWAIT = 0,
enum TDB_ERROR tdb_transaction_recover(struct tdb_context *tdb);
tdb_bool_err tdb_needs_recovery(struct tdb_context *tdb);
-/* this is stored at the front of every database */
-struct tdb1_header {
- char magic_food[32]; /* for /etc/magic */
- uint32_t version; /* version of the code */
- uint32_t hash_size; /* number of hash entries */
- tdb1_off_t rwlocks; /* obsolete - kept to detect old formats */
- tdb1_off_t recovery_start; /* offset of transaction recovery region */
- tdb1_off_t sequence_number; /* used when TDB1_SEQNUM is set */
- uint32_t magic1_hash; /* hash of TDB_MAGIC_FOOD. */
- uint32_t magic2_hash; /* hash of TDB1_MAGIC. */
- tdb1_off_t reserved[27];
-};
-
-struct tdb1_traverse_lock {
- struct tdb1_traverse_lock *next;
- uint32_t off;
- uint32_t hash;
- int lock_rw;
-};
-
struct tdb_context {
/* Single list of all TDBs, to detect multiple opens. */
struct tdb_context *next;
/* Direct access information */
struct tdb_access_hdr *access;
} tdb2;
-
- struct {
- int traverse_read; /* read-only traversal */
- int traverse_write; /* read-write traversal */
-
- struct tdb1_header header; /* a cached copy of the header */
- struct tdb1_traverse_lock travlocks; /* current traversal locks */
- const struct tdb1_methods *io;
- struct tdb1_transaction *transaction;
- int page_size;
- int max_dead_records;
- } tdb1;
};
-#define TDB1_BYTEREV(x) (((((x)&0xff)<<24)|((x)&0xFF00)<<8)|(((x)>>8)&0xFF00)|((x)>>24))
-
-/* tdb1_check.c: */
-int tdb1_check(struct tdb_context *tdb,
- enum TDB_ERROR (*check)(TDB_DATA key, TDB_DATA data, void *),
- void *private_data);
-
-
-/* tdb1_open.c: */
-enum TDB_ERROR tdb1_new_database(struct tdb_context *tdb,
- struct tdb_attribute_tdb1_hashsize *hashsize,
- struct tdb_attribute_tdb1_max_dead *max_dead);
-enum TDB_ERROR tdb1_open(struct tdb_context *tdb,
- struct tdb_attribute_tdb1_max_dead *max_dead);
-
-/* tdb1_io.c: */
-enum TDB_ERROR tdb1_probe_length(struct tdb_context *tdb);
-
-/* tdb1_lock.c: */
-int tdb1_allrecord_lock(struct tdb_context *tdb, int ltype,
- enum tdb_lock_flags flags, bool upgradable);
-int tdb1_allrecord_unlock(struct tdb_context *tdb, int ltype);
-
-int tdb1_chainlock(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainunlock(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
-
-/* tdb1_transaction.c: */
-int tdb1_transaction_recover(struct tdb_context *tdb);
-int tdb1_transaction_cancel(struct tdb_context *tdb);
-
-/* tdb1_traverse.c: */
-int tdb1_traverse(struct tdb_context *tdb,
- int (*)(struct tdb_context *, TDB_DATA, TDB_DATA, void *),
- void *private_data);
-
-/* tdb1_summary.c: */
-char *tdb1_summary(struct tdb_context *tdb);
-
-/* tdb1_tdb.c: */
-int tdb1_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
-enum TDB_ERROR tdb1_fetch(struct tdb_context *tdb, TDB_DATA key,
- TDB_DATA *data);
-int tdb1_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf);
-int tdb1_delete(struct tdb_context *tdb, TDB_DATA key);
-int tdb1_exists(struct tdb_context *tdb, TDB_DATA key);
-enum TDB_ERROR tdb1_parse_record(struct tdb_context *tdb, TDB_DATA key,
- enum TDB_ERROR (*parser)(TDB_DATA key,
- TDB_DATA data,
- void *private_data),
- void *private_data);
-void tdb1_increment_seqnum_nonblock(struct tdb_context *tdb);
-int tdb1_get_seqnum(struct tdb_context *tdb);
-int tdb1_wipe_all(struct tdb_context *tdb);
-
-/* tdb1_transaction.c: */
-int tdb1_transaction_start(struct tdb_context *tdb);
-int tdb1_transaction_prepare_commit(struct tdb_context *tdb);
-int tdb1_transaction_commit(struct tdb_context *tdb);
-
-/* tdb1_traverse.c: */
-TDB_DATA tdb1_firstkey(struct tdb_context *tdb);
-TDB_DATA tdb1_nextkey(struct tdb_context *tdb, TDB_DATA key);
-
/* tdb.c: */
enum TDB_ERROR COLD PRINTF_FMT(4, 5)
tdb_logerr(struct tdb_context *tdb,
char *hashesg, *freeg, *keysg, *datag, *extrag, *uncoalg;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- /* tdb1 doesn't do graphs. */
- *summary = tdb1_summary(tdb);
- if (!*summary)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
hashesg = freeg = keysg = datag = extrag = uncoalg = NULL;
ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
struct tdb_used_record rec;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_store(tdb, key, dbuf, flag) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
return tdb->last_error = TDB_OFF_TO_ERR(off);
struct tdb_data new_dbuf;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_append(tdb, key, dbuf) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
return tdb->last_error = TDB_OFF_TO_ERR(off);
struct hash_info h;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1)
- return tdb1_fetch(tdb, key, data);
-
off = find_and_lock(tdb, key, F_RDLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
return tdb->last_error = TDB_OFF_TO_ERR(off);
struct tdb_used_record rec;
struct hash_info h;
- if (tdb->flags & TDB_VERSION1) {
- return tdb1_exists(tdb, key);
- }
-
off = find_and_lock(tdb, key, F_RDLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
tdb->last_error = TDB_OFF_TO_ERR(off);
struct hash_info h;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_delete(tdb, key) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
off = find_and_lock(tdb, key, F_WRLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
return tdb->last_error = TDB_OFF_TO_ERR(off);
static bool inside_transaction(const struct tdb_context *tdb)
{
- if (tdb->flags & TDB_VERSION1)
- return tdb->tdb1.transaction != NULL;
- else
- return tdb->tdb2.transaction != NULL;
+ return tdb->tdb2.transaction != NULL;
}
static bool readonly_changable(struct tdb_context *tdb, const char *caller)
struct hash_info h;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- return tdb->last_error = tdb1_parse_record(tdb, key, parse,
- data);
- }
-
off = find_and_lock(tdb, key, F_RDLCK, &h, &rec, NULL);
if (TDB_OFF_IS_ERR(off)) {
return tdb->last_error = TDB_OFF_TO_ERR(off);
{
tdb_off_t off;
- if (tdb->flags & TDB_VERSION1) {
- tdb1_off_t val;
- tdb->last_error = TDB_SUCCESS;
- val = tdb1_get_seqnum(tdb);
-
- if (tdb->last_error != TDB_SUCCESS)
- return TDB_ERR_TO_OFF(tdb->last_error);
- else
- return val;
- }
-
off = tdb_read_off(tdb, offsetof(struct tdb_header, seqnum));
if (TDB_OFF_IS_ERR(off))
tdb->last_error = TDB_OFF_TO_ERR(off);
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Rusty Russell 2009
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#include "tdb1_private.h"
-
-/* Since we opened it, these shouldn't fail unless it's recent corruption. */
-static bool tdb1_check_header(struct tdb_context *tdb, tdb1_off_t *recovery)
-{
- struct tdb1_header hdr;
- uint32_t h1, h2;
-
- if (tdb->tdb1.io->tdb1_read(tdb, 0, &hdr, sizeof(hdr), 0) == -1)
- return false;
- if (strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0)
- goto corrupt;
-
- TDB1_CONV(hdr);
- if (hdr.version != TDB1_VERSION)
- goto corrupt;
-
- if (hdr.rwlocks != 0 && hdr.rwlocks != TDB1_HASH_RWLOCK_MAGIC)
- goto corrupt;
-
- tdb1_header_hash(tdb, &h1, &h2);
- if (hdr.magic1_hash && hdr.magic2_hash &&
- (hdr.magic1_hash != h1 || hdr.magic2_hash != h2))
- goto corrupt;
-
- if (hdr.hash_size == 0)
- goto corrupt;
-
- if (hdr.hash_size != tdb->tdb1.header.hash_size)
- goto corrupt;
-
- if (hdr.recovery_start != 0 &&
- hdr.recovery_start < TDB1_DATA_START(tdb->tdb1.header.hash_size))
- goto corrupt;
-
- *recovery = hdr.recovery_start;
- return true;
-
-corrupt:
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Header is corrupt\n");
- return false;
-}
-
-/* Generic record header check. */
-static bool tdb1_check_record(struct tdb_context *tdb,
- tdb1_off_t off,
- const struct tdb1_record *rec)
-{
- tdb1_off_t tailer;
-
- /* Check rec->next: 0 or points to record offset, aligned. */
- if (rec->next > 0 && rec->next < TDB1_DATA_START(tdb->tdb1.header.hash_size)){
- 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) {
- 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) {
- tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Record offset %d misaligned next %d\n",
- off, rec->next);
- goto corrupt;
- }
- if (tdb->tdb1.io->tdb1_oob(tdb, rec->next+sizeof(*rec), 0))
- goto corrupt;
-
- /* Check rec_len: similar to rec->next, implies next record. */
- if ((rec->rec_len % TDB1_ALIGNMENT) != 0) {
- 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)) {
- 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. */
- if (tdb->tdb1.io->tdb1_oob(tdb, off+sizeof(*rec)+rec->rec_len, 0))
- goto corrupt;
-
- /* Check tailer. */
- if (tdb1_ofs_read(tdb, off+sizeof(*rec)+rec->rec_len-sizeof(tailer),
- &tailer) == -1)
- goto corrupt;
- if (tailer != sizeof(*rec) + rec->rec_len) {
- tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Record offset %d invalid tailer\n", off);
- goto corrupt;
- }
-
- return true;
-
-corrupt:
- tdb->last_error = TDB_ERR_CORRUPT;
- return false;
-}
-
-/* Grab some bytes: may copy if can't use mmap.
- Caller has already done bounds check. */
-static TDB_DATA get_bytes(struct tdb_context *tdb,
- tdb1_off_t off, tdb1_len_t len)
-{
- TDB_DATA d;
-
- d.dsize = len;
-
- if (tdb->tdb1.transaction == NULL && tdb->file->map_ptr != NULL)
- d.dptr = (unsigned char *)tdb->file->map_ptr + off;
- else
- d.dptr = tdb1_alloc_read(tdb, off, d.dsize);
- return d;
-}
-
-/* Frees data if we're not able to simply use mmap. */
-static void put_bytes(struct tdb_context *tdb, TDB_DATA d)
-{
- if (tdb->tdb1.transaction == NULL && tdb->file->map_ptr != NULL)
- return;
- free(d.dptr);
-}
-
-/* We use the excellent Jenkins lookup3 hash; this is based on hash_word2.
- * See: http://burtleburtle.net/bob/c/lookup3.c
- */
-#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
-static void jhash(uint32_t key, uint32_t *pc, uint32_t *pb)
-{
- uint32_t a,b,c;
-
- /* Set up the internal state */
- a = b = c = 0xdeadbeef + *pc;
- c += *pb;
- a += key;
- c ^= b; c -= rot(b,14);
- a ^= c; a -= rot(c,11);
- b ^= a; b -= rot(a,25);
- c ^= b; c -= rot(b,16);
- a ^= c; a -= rot(c,4);
- b ^= a; b -= rot(a,14);
- c ^= b; c -= rot(b,24);
- *pc=c; *pb=b;
-}
-
-/*
- We want to check that all free records are in the free list
- (only once), and all free list entries are free records. Similarly
- for each hash chain of used records.
-
- Doing that naively (without walking hash chains, since we want to be
- linear) means keeping a list of records which have been seen in each
- hash chain, and another of records pointed to (ie. next pointers
- from records and the initial hash chain heads). These two lists
- should be equal. This will take 8 bytes per record, and require
- sorting at the end.
-
- So instead, we record each offset in a bitmap such a way that
- recording it twice will cancel out. Since each offset should appear
- exactly twice, the bitmap should be zero at the end.
-
- The approach was inspired by Bloom Filters (see Wikipedia). For
- each value, we flip K bits in a bitmap of size N. The number of
- distinct arrangements is:
-
- N! / (K! * (N-K)!)
-
- Of course, not all arrangements are actually distinct, but testing
- shows this formula to be close enough.
-
- So, if K == 8 and N == 256, the probability of two things flipping the same
- bits is 1 in 409,663,695,276,000.
-
- Given that ldb uses a hash size of 10000, using 32 bytes per hash chain
- (320k) seems reasonable.
-*/
-#define NUM_HASHES 8
-#define BITMAP_BITS 256
-
-static void bit_flip(unsigned char bits[], unsigned int idx)
-{
- bits[idx / CHAR_BIT] ^= (1 << (idx % CHAR_BIT));
-}
-
-/* We record offsets in a bitmap for the particular chain it should be in. */
-static void record_offset(unsigned char bits[], tdb1_off_t off)
-{
- uint32_t h1 = off, h2 = 0;
- unsigned int i;
-
- /* We get two good hash values out of jhash2, so we use both. Then
- * we keep going to produce further hash values. */
- for (i = 0; i < NUM_HASHES / 2; i++) {
- jhash(off, &h1, &h2);
- bit_flip(bits, h1 % BITMAP_BITS);
- bit_flip(bits, h2 % BITMAP_BITS);
- h2++;
- }
-}
-
-/* Check that an in-use record is valid. */
-static bool tdb1_check_used_record(struct tdb_context *tdb,
- tdb1_off_t off,
- const struct tdb1_record *rec,
- unsigned char **hashes,
- enum TDB_ERROR (*check)(TDB_DATA, TDB_DATA,
- void *),
- void *private_data)
-{
- TDB_DATA key, data;
-
- if (!tdb1_check_record(tdb, off, rec))
- return false;
-
- /* key + data + tailer must fit in record */
- if (rec->key_len + rec->data_len + sizeof(tdb1_off_t) > rec->rec_len) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Record offset %d too short for contents\n", off);
- return false;
- }
-
- key = get_bytes(tdb, off + sizeof(*rec), rec->key_len);
- if (!key.dptr)
- return false;
-
- if ((uint32_t)tdb_hash(tdb, key.dptr, key.dsize) != rec->full_hash) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Record offset %d has incorrect hash\n", off);
- goto fail_put_key;
- }
-
- /* Mark this offset as a known value for this hash bucket. */
- record_offset(hashes[TDB1_BUCKET(rec->full_hash)+1], off);
- /* And similarly if the next pointer is valid. */
- if (rec->next)
- record_offset(hashes[TDB1_BUCKET(rec->full_hash)+1], rec->next);
-
- /* If they supply a check function and this record isn't dead,
- get data and feed it. */
- if (check && rec->magic != TDB1_DEAD_MAGIC) {
- enum TDB_ERROR ecode;
-
- data = get_bytes(tdb, off + sizeof(*rec) + rec->key_len,
- rec->data_len);
- if (!data.dptr)
- goto fail_put_key;
-
- ecode = check(key, data, private_data);
- if (ecode != TDB_SUCCESS) {
- tdb->last_error = ecode;
- goto fail_put_data;
- }
- put_bytes(tdb, data);
- }
-
- put_bytes(tdb, key);
- return true;
-
-fail_put_data:
- put_bytes(tdb, data);
-fail_put_key:
- put_bytes(tdb, key);
- return false;
-}
-
-/* Check that an unused record is valid. */
-static bool tdb1_check_free_record(struct tdb_context *tdb,
- tdb1_off_t off,
- const struct tdb1_record *rec,
- unsigned char **hashes)
-{
- if (!tdb1_check_record(tdb, off, rec))
- return false;
-
- /* Mark this offset as a known value for the free list. */
- record_offset(hashes[0], off);
- /* And similarly if the next pointer is valid. */
- if (rec->next)
- record_offset(hashes[0], rec->next);
- return true;
-}
-
-/* Slow, but should be very rare. */
-size_t tdb1_dead_space(struct tdb_context *tdb, tdb1_off_t off)
-{
- size_t len;
-
- for (len = 0; off + len < tdb->file->map_size; len++) {
- char c;
- if (tdb->tdb1.io->tdb1_read(tdb, off, &c, 1, 0))
- return 0;
- if (c != 0 && c != 0x42)
- break;
- }
- return len;
-}
-
-int tdb1_check(struct tdb_context *tdb,
- enum TDB_ERROR (*check)(TDB_DATA key, TDB_DATA data, void *),
- void *private_data)
-{
- unsigned int h;
- unsigned char **hashes;
- tdb1_off_t off, recovery_start;
- struct tdb1_record rec;
- bool found_recovery = false;
- tdb1_len_t dead;
- bool locked;
- size_t alloc_len;
-
- /* We may have a write lock already, so don't re-lock. */
- if (tdb->file->allrecord_lock.count != 0) {
- locked = false;
- } else {
- if (tdb_lockall_read(tdb) != TDB_SUCCESS)
- return -1;
- locked = true;
- }
-
- /* Make sure we know true size of the underlying file. */
- tdb->tdb1.io->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
-
- /* Header must be OK: also gets us the recovery ptr, if any. */
- if (!tdb1_check_header(tdb, &recovery_start))
- goto unlock;
-
- /* We should have the whole header, too. */
- if (tdb->file->map_size < TDB1_DATA_START(tdb->tdb1.header.hash_size)) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "File too short for hashes\n");
- goto unlock;
- }
-
- /* One big malloc: pointers then bit arrays. */
- alloc_len = sizeof(hashes[0]) * (1+tdb->tdb1.header.hash_size)
- + BITMAP_BITS / CHAR_BIT * (1+tdb->tdb1.header.hash_size);
- hashes = (unsigned char **)calloc(1, alloc_len);
- if (!hashes) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
- "tdb_check: could not allocate %zu",
- alloc_len);
- goto unlock;
- }
-
- /* Initialize pointers */
- hashes[0] = (unsigned char *)(&hashes[1+tdb->tdb1.header.hash_size]);
- for (h = 1; h < 1+tdb->tdb1.header.hash_size; h++)
- hashes[h] = hashes[h-1] + BITMAP_BITS / CHAR_BIT;
-
- /* Freelist and hash headers are all in a row: read them. */
- for (h = 0; h < 1+tdb->tdb1.header.hash_size; h++) {
- if (tdb1_ofs_read(tdb, TDB1_FREELIST_TOP + h*sizeof(tdb1_off_t),
- &off) == -1)
- goto free;
- if (off)
- record_offset(hashes[h], off);
- }
-
- /* For each record, read it in and check it's ok. */
- for (off = TDB1_DATA_START(tdb->tdb1.header.hash_size);
- off < tdb->file->map_size;
- off += sizeof(rec) + rec.rec_len) {
- if (tdb->tdb1.io->tdb1_read(tdb, off, &rec, sizeof(rec),
- TDB1_DOCONV()) == -1)
- goto free;
- switch (rec.magic) {
- case TDB1_MAGIC:
- case TDB1_DEAD_MAGIC:
- if (!tdb1_check_used_record(tdb, off, &rec, hashes,
- check, private_data))
- goto free;
- break;
- case TDB1_FREE_MAGIC:
- if (!tdb1_check_free_record(tdb, off, &rec, hashes))
- goto free;
- break;
- /* If we crash after ftruncate, we can get zeroes or fill. */
- case TDB1_RECOVERY_INVALID_MAGIC:
- case 0x42424242:
- if (recovery_start == off) {
- found_recovery = true;
- break;
- }
- dead = tdb1_dead_space(tdb, off);
- if (dead < sizeof(rec))
- goto corrupt;
-
- tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
- "Dead space at %d-%d (of %u)\n",
- off, off + dead,
- (unsigned)tdb->file->map_size);
- rec.rec_len = dead - sizeof(rec);
- break;
- case TDB1_RECOVERY_MAGIC:
- if (recovery_start != 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->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Bad magic 0x%x at offset %d\n",
- rec.magic, off);
- goto free;
- }
- }
-
- /* Now, hashes should all be empty: each record exists and is referred
- * to by one other. */
- for (h = 0; h < 1+tdb->tdb1.header.hash_size; h++) {
- unsigned int i;
- for (i = 0; i < BITMAP_BITS / CHAR_BIT; i++) {
- if (hashes[h][i] != 0) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Hashes do not match records\n");
- goto free;
- }
- }
- }
-
- /* We must have found recovery area if there was one. */
- if (recovery_start != 0 && !found_recovery) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "Expected a recovery area at %u\n",
- recovery_start);
- goto free;
- }
-
- free(hashes);
- if (locked) {
- tdb_unlockall_read(tdb);
- }
- return 0;
-
-free:
- free(hashes);
-unlock:
- if (locked) {
- tdb_unlockall_read(tdb);
- }
- return -1;
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "tdb1_private.h"
-
-/* read a freelist record and check for simple errors */
-int tdb1_rec_free_read(struct tdb_context *tdb, tdb1_off_t off, struct tdb1_record *rec)
-{
- 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 */
- 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->tdb1.io->tdb1_write(tdb, off, rec, sizeof(*rec)) == -1)
- return -1;
- }
-
- if (rec->magic != TDB1_FREE_MAGIC) {
- 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->tdb1.io->tdb1_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
- return -1;
- return 0;
-}
-
-
-/* update a record tailer (must hold allocation lock) */
-static int update_tailer(struct tdb_context *tdb, tdb1_off_t offset,
- const struct tdb1_record *rec)
-{
- tdb1_off_t totalsize;
-
- /* Offset of tailer from record header */
- totalsize = sizeof(*rec) + rec->rec_len;
- return tdb1_ofs_write(tdb, offset + totalsize - sizeof(tdb1_off_t),
- &totalsize);
-}
-
-/* Add an element into the freelist. Merge adjacent records if
- necessary. */
-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)
- return -1;
-
- /* set an initial tailer, so if we fail we don't leave a bogus record */
- if (update_tailer(tdb, offset, rec) != 0) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb_free: update_tailer failed!\n");
- goto fail;
- }
-
- tdb->stats.alloc_coalesce_tried++;
- /* Look left */
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_free: left offset read failed at %u", left);
- goto update;
- }
-
- /* it could be uninitialised data */
- if (leftsize == 0 || leftsize == TDB1_PAD_U32) {
- goto update;
- }
-
- left = offset - leftsize;
-
- if (leftsize > offset ||
- left < TDB1_DATA_START(tdb->tdb1.header.hash_size)) {
- goto update;
- }
-
- /* Now read in the left record */
- 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;
- }
-
- /* If it's free, expand to include it. */
- if (l.magic == TDB1_FREE_MAGIC) {
- /* we now merge the new record into the left record, rather than the other
- way around. This makes the operation O(1) instead of O(n). This change
- 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) {
- 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) {
- 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;
- }
- }
-
-update:
-
- /* Now, prepend to free list */
- rec->magic = TDB1_FREE_MAGIC;
-
- 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) {
- 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;
-
- fail:
- tdb1_unlock(tdb, -1, F_WRLCK);
- return -1;
-}
-
-
-
-/*
- the core of tdb1_allocate - called when we have decided which
- free list entry to use
-
- Note that we try to allocate by grabbing data from the end of an existing record,
- 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 tdb_context *tdb,
- tdb1_len_t length, tdb1_off_t rec_ptr,
- struct tdb1_record *rec, tdb1_off_t last_ptr)
-{
-#define MIN_REC_SIZE (sizeof(struct tdb1_record) + sizeof(tdb1_off_t) + 8)
-
- if (rec->rec_len < length + MIN_REC_SIZE) {
- /* we have to grab the whole record */
-
- /* unlink it from the previous record */
- if (tdb1_ofs_write(tdb, last_ptr, &rec->next) == -1) {
- return 0;
- }
-
- /* mark it not free */
- rec->magic = TDB1_MAGIC;
- if (tdb1_rec_write(tdb, rec_ptr, rec) == -1) {
- return 0;
- }
- tdb->stats.allocs++;
- return rec_ptr;
- }
-
- /* we're going to just shorten the existing record */
- rec->rec_len -= (length + sizeof(*rec));
- if (tdb1_rec_write(tdb, rec_ptr, rec) == -1) {
- return 0;
- }
- if (update_tailer(tdb, rec_ptr, rec) == -1) {
- return 0;
- }
-
- /* and setup the new record */
- rec_ptr += sizeof(*rec) + rec->rec_len;
-
- memset(rec, '\0', sizeof(*rec));
- rec->rec_len = length;
- rec->magic = TDB1_MAGIC;
-
- if (tdb1_rec_write(tdb, rec_ptr, rec) == -1) {
- return 0;
- }
-
- if (update_tailer(tdb, rec_ptr, rec) == -1) {
- return 0;
- }
-
- tdb->stats.allocs++;
- tdb->stats.alloc_leftover++;
- return rec_ptr;
-}
-
-/* allocate some space from the free list. The offset returned points
- to a unconnected tdb1_record within the database with room for at
- least length bytes of total data
-
- 0 is returned if the space could not be allocated
- */
-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_off_t rec_ptr, last_ptr;
- tdb1_len_t rec_len;
- } bestfit;
- float multiplier = 1.0;
-
- if (tdb1_lock(tdb, -1, F_WRLCK) == -1)
- return 0;
-
- /* over-allocate to reduce fragmentation */
- length *= 1.25;
-
- /* Extra bytes required for tailer */
- length += sizeof(tdb1_off_t);
- length = TDB1_ALIGN(length, TDB1_ALIGNMENT);
-
- again:
- last_ptr = TDB1_FREELIST_TOP;
-
- /* read in the freelist top */
- if (tdb1_ofs_read(tdb, TDB1_FREELIST_TOP, &rec_ptr) == -1)
- goto fail;
-
- bestfit.rec_ptr = 0;
- bestfit.last_ptr = 0;
- bestfit.rec_len = 0;
-
- /*
- this is a best fit allocation strategy. Originally we used
- a first fit strategy, but it suffered from massive fragmentation
- issues when faced with a slowly increasing record size.
- */
- while (rec_ptr) {
- if (tdb1_rec_free_read(tdb, rec_ptr, rec) == -1) {
- goto fail;
- }
-
- if (rec->rec_len >= length) {
- if (bestfit.rec_ptr == 0 ||
- rec->rec_len < bestfit.rec_len) {
- bestfit.rec_len = rec->rec_len;
- bestfit.rec_ptr = rec_ptr;
- bestfit.last_ptr = last_ptr;
- }
- }
-
- /* move to the next record */
- last_ptr = rec_ptr;
- rec_ptr = rec->next;
-
- /* if we've found a record that is big enough, then
- stop searching if its also not too big. The
- definition of 'too big' changes as we scan
- through */
- if (bestfit.rec_len > 0 &&
- bestfit.rec_len < length * multiplier) {
- break;
- }
-
- /* this multiplier means we only extremely rarely
- search more than 50 or so records. At 50 records we
- accept records up to 11 times larger than what we
- want */
- multiplier *= 1.05;
- }
-
- if (bestfit.rec_ptr != 0) {
- if (tdb1_rec_free_read(tdb, bestfit.rec_ptr, rec) == -1) {
- goto fail;
- }
-
- newrec_ptr = tdb1_allocate_ofs(tdb, length, bestfit.rec_ptr,
- rec, bestfit.last_ptr);
- tdb1_unlock(tdb, -1, F_WRLCK);
- return newrec_ptr;
- }
-
- /* we didn't find enough space. See if we can expand the
- database and if we can then try again */
- if (tdb1_expand(tdb, length + sizeof(*rec)) == 0)
- goto again;
- fail:
- tdb1_unlock(tdb, -1, F_WRLCK);
- return 0;
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Rusty Russell 2010
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#include "tdb1_private.h"
-
-/* This is based on the hash algorithm from gdbm */
-uint64_t tdb1_old_hash(const void *key, size_t len, uint64_t seed, void *unused)
-{
- uint32_t value; /* Used to compute the hash value. */
- uint32_t i; /* Used to cycle through random values. */
- const unsigned char *dptr = key;
-
- /* Set the initial value from the key size. */
- for (value = 0x238F13AF * len, i=0; i < len; i++)
- value = (value + (dptr[i] << (i*5 % 24)));
-
- return (1103515243 * value + 12345);
-}
-
-#ifndef WORDS_BIGENDIAN
-# define HASH_LITTLE_ENDIAN 1
-# define HASH_BIG_ENDIAN 0
-#else
-# define HASH_LITTLE_ENDIAN 0
-# define HASH_BIG_ENDIAN 1
-#endif
-
-/*
--------------------------------------------------------------------------------
-lookup3.c, by Bob Jenkins, May 2006, Public Domain.
-
-These are functions for producing 32-bit hashes for hash table lookup.
-hash_word(), hashlittle(), hashlittle2(), hashbig(), mix(), and final()
-are externally useful functions. Routines to test the hash are included
-if SELF_TEST is defined. You can use this free for any purpose. It's in
-the public domain. It has no warranty.
-
-You probably want to use hashlittle(). hashlittle() and hashbig()
-hash byte arrays. hashlittle() is is faster than hashbig() on
-little-endian machines. Intel and AMD are little-endian machines.
-On second thought, you probably want hashlittle2(), which is identical to
-hashlittle() except it returns two 32-bit hashes for the price of one.
-You could implement hashbig2() if you wanted but I haven't bothered here.
-
-If you want to find a hash of, say, exactly 7 integers, do
- a = i1; b = i2; c = i3;
- mix(a,b,c);
- a += i4; b += i5; c += i6;
- mix(a,b,c);
- a += i7;
- final(a,b,c);
-then use c as the hash value. If you have a variable length array of
-4-byte integers to hash, use hash_word(). If you have a byte array (like
-a character string), use hashlittle(). If you have several byte arrays, or
-a mix of things, see the comments above hashlittle().
-
-Why is this so big? I read 12 bytes at a time into 3 4-byte integers,
-then mix those integers. This is fast (you can do a lot more thorough
-mixing with 12*3 instructions on 3 integers than you can with 3 instructions
-on 1 byte), but shoehorning those bytes into integers efficiently is messy.
-*/
-
-#define hashsize(n) ((uint32_t)1<<(n))
-#define hashmask(n) (hashsize(n)-1)
-#define rot(x,k) (((x)<<(k)) | ((x)>>(32-(k))))
-
-/*
--------------------------------------------------------------------------------
-mix -- mix 3 32-bit values reversibly.
-
-This is reversible, so any information in (a,b,c) before mix() is
-still in (a,b,c) after mix().
-
-If four pairs of (a,b,c) inputs are run through mix(), or through
-mix() in reverse, there are at least 32 bits of the output that
-are sometimes the same for one pair and different for another pair.
-This was tested for:
-* pairs that differed by one bit, by two bits, in any combination
- of top bits of (a,b,c), or in any combination of bottom bits of
- (a,b,c).
-* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- is commonly produced by subtraction) look like a single 1-bit
- difference.
-* the base values were pseudorandom, all zero but one bit set, or
- all zero plus a counter that starts at zero.
-
-Some k values for my "a-=c; a^=rot(c,k); c+=b;" arrangement that
-satisfy this are
- 4 6 8 16 19 4
- 9 15 3 18 27 15
- 14 9 3 7 17 3
-Well, "9 15 3 18 27 15" didn't quite get 32 bits diffing
-for "differ" defined as + with a one-bit base and a two-bit delta. I
-used http://burtleburtle.net/bob/hash/avalanche.html to choose
-the operations, constants, and arrangements of the variables.
-
-This does not achieve avalanche. There are input bits of (a,b,c)
-that fail to affect some output bits of (a,b,c), especially of a. The
-most thoroughly mixed value is c, but it doesn't really even achieve
-avalanche in c.
-
-This allows some parallelism. Read-after-writes are good at doubling
-the number of bits affected, so the goal of mixing pulls in the opposite
-direction as the goal of parallelism. I did what I could. Rotates
-seem to cost as much as shifts on every machine I could lay my hands
-on, and rotates are much kinder to the top and bottom bits, so I used
-rotates.
--------------------------------------------------------------------------------
-*/
-#define mix(a,b,c) \
-{ \
- a -= c; a ^= rot(c, 4); c += b; \
- b -= a; b ^= rot(a, 6); a += c; \
- c -= b; c ^= rot(b, 8); b += a; \
- a -= c; a ^= rot(c,16); c += b; \
- b -= a; b ^= rot(a,19); a += c; \
- c -= b; c ^= rot(b, 4); b += a; \
-}
-
-/*
--------------------------------------------------------------------------------
-final -- final mixing of 3 32-bit values (a,b,c) into c
-
-Pairs of (a,b,c) values differing in only a few bits will usually
-produce values of c that look totally different. This was tested for
-* pairs that differed by one bit, by two bits, in any combination
- of top bits of (a,b,c), or in any combination of bottom bits of
- (a,b,c).
-* "differ" is defined as +, -, ^, or ~^. For + and -, I transformed
- the output delta to a Gray code (a^(a>>1)) so a string of 1's (as
- is commonly produced by subtraction) look like a single 1-bit
- difference.
-* the base values were pseudorandom, all zero but one bit set, or
- all zero plus a counter that starts at zero.
-
-These constants passed:
- 14 11 25 16 4 14 24
- 12 14 25 16 4 14 24
-and these came close:
- 4 8 15 26 3 22 24
- 10 8 15 26 3 22 24
- 11 8 15 26 3 22 24
--------------------------------------------------------------------------------
-*/
-#define final(a,b,c) \
-{ \
- c ^= b; c -= rot(b,14); \
- a ^= c; a -= rot(c,11); \
- b ^= a; b -= rot(a,25); \
- c ^= b; c -= rot(b,16); \
- a ^= c; a -= rot(c,4); \
- b ^= a; b -= rot(a,14); \
- c ^= b; c -= rot(b,24); \
-}
-
-
-/*
--------------------------------------------------------------------------------
-hashlittle() -- hash a variable-length key into a 32-bit value
- k : the key (the unaligned variable-length array of bytes)
- length : the length of the key, counting by bytes
- val2 : IN: can be any 4-byte value OUT: second 32 bit hash.
-Returns a 32-bit value. Every bit of the key affects every bit of
-the return value. Two keys differing by one or two bits will have
-totally different hash values. Note that the return value is better
-mixed than val2, so use that first.
-
-The best hash table sizes are powers of 2. There is no need to do
-mod a prime (mod is sooo slow!). If you need less than 32 bits,
-use a bitmask. For example, if you need only 10 bits, do
- h = (h & hashmask(10));
-In which case, the hash table should have hashsize(10) elements.
-
-If you are hashing n strings (uint8_t **)k, do it like this:
- for (i=0, h=0; i<n; ++i) h = hashlittle( k[i], len[i], h);
-
-By Bob Jenkins, 2006. bob_jenkins@burtleburtle.net. You may use this
-code any way you wish, private, educational, or commercial. It's free.
-
-Use for hash table lookup, or anything where one collision in 2^^32 is
-acceptable. Do NOT use for cryptographic purposes.
--------------------------------------------------------------------------------
-*/
-
-static uint32_t hashlittle( const void *key, size_t length )
-{
- uint32_t a,b,c; /* internal state */
- union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
-
- /* Set up the internal state */
- a = b = c = 0xdeadbeef + ((uint32_t)length);
-
- u.ptr = key;
- if (HASH_LITTLE_ENDIAN && ((u.i & 0x3) == 0)) {
- const uint32_t *k = (const uint32_t *)key; /* read 32-bit chunks */
- const uint8_t *k8;
-
- /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
- while (length > 12)
- {
- a += k[0];
- b += k[1];
- c += k[2];
- mix(a,b,c);
- length -= 12;
- k += 3;
- }
-
- /*----------------------------- handle the last (probably partial) block */
- k8 = (const uint8_t *)k;
- switch(length)
- {
- case 12: c+=k[2]; b+=k[1]; a+=k[0]; break;
- case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
- case 10: c+=((uint32_t)k8[9])<<8; /* fall through */
- case 9 : c+=k8[8]; /* fall through */
- case 8 : b+=k[1]; a+=k[0]; break;
- case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
- case 6 : b+=((uint32_t)k8[5])<<8; /* fall through */
- case 5 : b+=k8[4]; /* fall through */
- case 4 : a+=k[0]; break;
- case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
- case 2 : a+=((uint32_t)k8[1])<<8; /* fall through */
- case 1 : a+=k8[0]; break;
- case 0 : return c;
- }
- } else if (HASH_LITTLE_ENDIAN && ((u.i & 0x1) == 0)) {
- const uint16_t *k = (const uint16_t *)key; /* read 16-bit chunks */
- const uint8_t *k8;
-
- /*--------------- all but last block: aligned reads and different mixing */
- while (length > 12)
- {
- a += k[0] + (((uint32_t)k[1])<<16);
- b += k[2] + (((uint32_t)k[3])<<16);
- c += k[4] + (((uint32_t)k[5])<<16);
- mix(a,b,c);
- length -= 12;
- k += 6;
- }
-
- /*----------------------------- handle the last (probably partial) block */
- k8 = (const uint8_t *)k;
- switch(length)
- {
- case 12: c+=k[4]+(((uint32_t)k[5])<<16);
- b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 11: c+=((uint32_t)k8[10])<<16; /* fall through */
- case 10: c+=k[4];
- b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 9 : c+=k8[8]; /* fall through */
- case 8 : b+=k[2]+(((uint32_t)k[3])<<16);
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 7 : b+=((uint32_t)k8[6])<<16; /* fall through */
- case 6 : b+=k[2];
- a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 5 : b+=k8[4]; /* fall through */
- case 4 : a+=k[0]+(((uint32_t)k[1])<<16);
- break;
- case 3 : a+=((uint32_t)k8[2])<<16; /* fall through */
- case 2 : a+=k[0];
- break;
- case 1 : a+=k8[0];
- break;
- case 0 : return c; /* zero length requires no mixing */
- }
-
- } else { /* need to read the key one byte at a time */
- const uint8_t *k = (const uint8_t *)key;
-
- /*--------------- all but the last block: affect some 32 bits of (a,b,c) */
- while (length > 12)
- {
- a += k[0];
- a += ((uint32_t)k[1])<<8;
- a += ((uint32_t)k[2])<<16;
- a += ((uint32_t)k[3])<<24;
- b += k[4];
- b += ((uint32_t)k[5])<<8;
- b += ((uint32_t)k[6])<<16;
- b += ((uint32_t)k[7])<<24;
- c += k[8];
- c += ((uint32_t)k[9])<<8;
- c += ((uint32_t)k[10])<<16;
- c += ((uint32_t)k[11])<<24;
- mix(a,b,c);
- length -= 12;
- k += 12;
- }
-
- /*-------------------------------- last block: affect all 32 bits of (c) */
- switch(length) /* all the case statements fall through */
- {
- case 12: c+=((uint32_t)k[11])<<24;
- case 11: c+=((uint32_t)k[10])<<16;
- case 10: c+=((uint32_t)k[9])<<8;
- case 9 : c+=k[8];
- case 8 : b+=((uint32_t)k[7])<<24;
- case 7 : b+=((uint32_t)k[6])<<16;
- case 6 : b+=((uint32_t)k[5])<<8;
- case 5 : b+=k[4];
- case 4 : a+=((uint32_t)k[3])<<24;
- case 3 : a+=((uint32_t)k[2])<<16;
- case 2 : a+=((uint32_t)k[1])<<8;
- case 1 : a+=k[0];
- break;
- case 0 : return c;
- }
- }
-
- final(a,b,c);
- return c;
-}
-
-_PUBLIC_ uint64_t tdb1_incompatible_hash(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return hashlittle(key, len);
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#include "tdb1_private.h"
-#ifndef MAX
-#define MAX(a,b) ((a) > (b) ? (a) : (b))
-#endif
-
-/* check for an out of bounds access - if it is out of bounds then
- see if the database has been expanded by someone else and expand
- if necessary
- note that "len" is the minimum length needed for the db
-*/
-static int tdb1_oob(struct tdb_context *tdb, tdb1_off_t len, int probe)
-{
- struct stat st;
- if (len <= tdb->file->map_size)
- return 0;
- if (tdb->flags & TDB_INTERNAL) {
- if (!probe) {
- 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->file->map_size);
- }
- return -1;
- }
-
- if (fstat(tdb->file->fd, &st) == -1) {
- tdb->last_error = TDB_ERR_IO;
- return -1;
- }
-
- if (st.st_size < (size_t)len) {
- if (!probe) {
- 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->last_error = TDB_ERR_IO;
- return -1;
- }
- tdb->file->map_size = st.st_size;
- return tdb1_mmap(tdb);
-}
-
-/* write a lump of data at a specified offset */
-static int tdb1_write(struct tdb_context *tdb, tdb1_off_t off,
- const void *buf, tdb1_len_t len)
-{
- if (len == 0) {
- return 0;
- }
-
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
- tdb->last_error = TDB_ERR_RDONLY;
- return -1;
- }
-
- if (tdb->tdb1.io->tdb1_oob(tdb, off + len, 0) != 0)
- return -1;
-
- if (tdb->file->map_ptr) {
- memcpy(off + (char *)tdb->file->map_ptr, buf, len);
- } else {
-#ifdef HAVE_INCOHERENT_MMAP
- tdb->last_error = TDB_ERR_IO;
- return -1;
-#else
- ssize_t written = pwrite(tdb->file->fd, buf, len, off);
- if ((written != (ssize_t)len) && (written != -1)) {
- 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->file->fd,
- (const char *)buf+written,
- len-written,
- off+written);
- }
- if (written == -1) {
- /* Ensure ecode is set for log fn. */
- 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->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;
- }
-#endif
- }
- return 0;
-}
-
-/* Endian conversion: we only ever deal with 4 byte quantities */
-void *tdb1_convert(void *buf, uint32_t size)
-{
- uint32_t i, *p = (uint32_t *)buf;
- for (i = 0; i < size / 4; i++)
- p[i] = TDB1_BYTEREV(p[i]);
- return buf;
-}
-
-
-/* read a lump of data at a specified offset, maybe convert */
-static int tdb1_read(struct tdb_context *tdb, tdb1_off_t off, void *buf,
- tdb1_len_t len, int cv)
-{
- if (tdb->tdb1.io->tdb1_oob(tdb, off + len, 0) != 0) {
- return -1;
- }
-
- if (tdb->file->map_ptr) {
- memcpy(buf, off + (char *)tdb->file->map_ptr, len);
- } else {
-#ifdef HAVE_INCOHERENT_MMAP
- tdb->last_error = TDB_ERR_IO;
- return -1;
-#else
- ssize_t ret = pread(tdb->file->fd, buf, len, off);
- if (ret != (ssize_t)len) {
- /* Ensure ecode is set for log fn. */
- 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->file->map_size);
- return -1;
- }
-#endif
- }
- if (cv) {
- tdb1_convert(buf, len);
- }
- return 0;
-}
-
-
-
-/*
- do an unlocked scan of the hash table heads to find the next non-zero head. The value
- will then be confirmed with the lock held
-*/
-static void tdb1_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
-{
- uint32_t h = *chain;
- if (tdb->file->map_ptr) {
- for (;h < tdb->tdb1.header.hash_size;h++) {
- if (0 != *(uint32_t *)(TDB1_HASH_TOP(h) + (unsigned char *)tdb->file->map_ptr)) {
- break;
- }
- }
- } else {
- uint32_t off=0;
- for (;h < tdb->tdb1.header.hash_size;h++) {
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(h), &off) != 0 || off != 0) {
- break;
- }
- }
- }
- (*chain) = h;
-}
-
-
-int tdb1_munmap(struct tdb_context *tdb)
-{
- if (tdb->flags & TDB_INTERNAL)
- return 0;
-
-#if HAVE_MMAP
- if (tdb->file->map_ptr) {
- int ret;
-
- ret = munmap(tdb->file->map_ptr, tdb->file->map_size);
- if (ret != 0)
- return ret;
- }
-#endif
- tdb->file->map_ptr = NULL;
- return 0;
-}
-
-/* If mmap isn't coherent, *everyone* must always mmap. */
-static bool should_mmap(const struct tdb_context *tdb)
-{
-#ifdef HAVE_INCOHERENT_MMAP
- return true;
-#else
- return !(tdb->flags & TDB_NOMMAP);
-#endif
-}
-
-int tdb1_mmap(struct tdb_context *tdb)
-{
- if (tdb->flags & TDB_INTERNAL)
- return 0;
-
-#if HAVE_MMAP
- if (should_mmap(tdb)) {
- int mmap_flags;
- if ((tdb->open_flags & O_ACCMODE) == O_RDONLY)
- mmap_flags = PROT_READ;
- else
- mmap_flags = PROT_READ | PROT_WRITE;
-
- tdb->file->map_ptr = mmap(NULL, tdb->file->map_size,
- mmap_flags,
- MAP_SHARED|MAP_FILE, tdb->file->fd, 0);
-
- /*
- * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
- */
-
- if (tdb->file->map_ptr == MAP_FAILED) {
- tdb->file->map_ptr = NULL;
- tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
- "tdb1_mmap failed for size %llu (%s)",
- (long long)tdb->file->map_size,
- strerror(errno));
-#ifdef HAVE_INCOHERENT_MMAP
- tdb->last_error = TDB_ERR_IO;
- return -1;
-#endif
- }
- } else {
- tdb->file->map_ptr = NULL;
- }
-#else
- tdb->file->map_ptr = NULL;
-#endif
- return 0;
-}
-
-/* expand a file. we prefer to use ftruncate, as that is what posix
- says to use for mmap expansion */
-static int tdb1_expand_file(struct tdb_context *tdb, tdb1_off_t size, tdb1_off_t addition)
-{
- char buf[8192];
-
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
- tdb->last_error = TDB_ERR_RDONLY;
- return -1;
- }
-
- if (ftruncate(tdb->file->fd, size+addition) == -1) {
- char b = 0;
- ssize_t written = pwrite(tdb->file->fd, &b, 1,
- (size+addition) - 1);
- if (written == 0) {
- /* try once more, potentially revealing errno */
- written = pwrite(tdb->file->fd, &b, 1,
- (size+addition) - 1);
- }
- if (written == 0) {
- /* again - give up, guessing errno */
- errno = ENOSPC;
- }
- if (written != 1) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "expand_file to %d failed (%s)",
- size+addition,
- strerror(errno));
- return -1;
- }
- }
-
- /* now fill the file with something. This ensures that the
- file isn't sparse, which would be very bad if we ran out of
- disk. This must be done with write, not via mmap */
- memset(buf, TDB1_PAD_BYTE, sizeof(buf));
- while (addition) {
- size_t n = addition>sizeof(buf)?sizeof(buf):addition;
- ssize_t written = pwrite(tdb->file->fd, buf, n, size);
- if (written == 0) {
- /* prevent infinite loops: try _once_ more */
- written = pwrite(tdb->file->fd, buf, n, size);
- }
- if (written == 0) {
- /* give up, trying to provide a useful errno */
- 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) {
- 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) {
- 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;
- }
- tdb->stats.expands++;
- return 0;
-}
-
-
-/* expand the database at least size bytes by expanding the underlying
- file and doing the mmap again if necessary */
-int tdb1_expand(struct tdb_context *tdb, tdb1_off_t size)
-{
- struct tdb1_record rec;
- tdb1_off_t offset, new_size, top_size, map_size;
-
- if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "lock failed in tdb1_expand");
- return -1;
- }
-
- /* must know about any previous expansions by another process */
- tdb->tdb1.io->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
-
- /* limit size in order to avoid using up huge amounts of memory for
- * in memory tdbs if an oddball huge record creeps in */
- if (size > 100 * 1024) {
- top_size = tdb->file->map_size + size * 2;
- } else {
- top_size = tdb->file->map_size + size * 100;
- }
-
- /* always make room for at least top_size more records, and at
- least 25% more space. if the DB is smaller than 100MiB,
- otherwise grow it by 10% only. */
- if (tdb->file->map_size > 100 * 1024 * 1024) {
- map_size = tdb->file->map_size * 1.10;
- } else {
- map_size = tdb->file->map_size * 1.25;
- }
-
- /* Round the database up to a multiple of the page size */
- new_size = MAX(top_size, map_size);
- size = TDB1_ALIGN(new_size, tdb->tdb1.page_size) - tdb->file->map_size;
-
- if (!(tdb->flags & TDB_INTERNAL))
- tdb1_munmap(tdb);
-
- /* expand the file itself */
- if (!(tdb->flags & TDB_INTERNAL)) {
- if (tdb->tdb1.io->tdb1_expand_file(tdb, tdb->file->map_size, size) != 0)
- goto fail;
- }
-
- tdb->file->map_size += size;
-
- if (tdb->flags & TDB_INTERNAL) {
- char *new_map_ptr = (char *)realloc(tdb->file->map_ptr,
- tdb->file->map_size);
- if (!new_map_ptr) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM,
- TDB_LOG_ERROR,
- "tdb1_expand: no memory");
- tdb->file->map_size -= size;
- goto fail;
- }
- tdb->file->map_ptr = new_map_ptr;
- } else {
- if (tdb1_mmap(tdb) != 0) {
- goto fail;
- }
- }
-
- /* form a new freelist record */
- memset(&rec,'\0',sizeof(rec));
- rec.rec_len = size - sizeof(rec);
-
- /* link it into the free list */
- offset = tdb->file->map_size - size;
- if (tdb1_free(tdb, offset, &rec) == -1)
- goto fail;
-
- tdb1_unlock(tdb, -1, F_WRLCK);
- return 0;
- fail:
- tdb1_unlock(tdb, -1, F_WRLCK);
- return -1;
-}
-
-/* read/write a tdb1_off_t */
-int tdb1_ofs_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
-{
- return tdb->tdb1.io->tdb1_read(tdb, offset, (char*)d, sizeof(*d), TDB1_DOCONV());
-}
-
-int tdb1_ofs_write(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
-{
- tdb1_off_t off = *d;
- return tdb->tdb1.io->tdb1_write(tdb, offset, TDB1_CONV(off), sizeof(*d));
-}
-
-
-/* read a lump of data, allocating the space for it */
-unsigned char *tdb1_alloc_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_len_t len)
-{
- unsigned char *buf;
-
- /* some systems don't like zero length malloc */
-
- if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
- 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->tdb1.io->tdb1_read(tdb, offset, buf, len, 0) == -1) {
- SAFE_FREE(buf);
- return NULL;
- }
- return buf;
-}
-
-/* Give a piece of tdb data to a parser */
-enum TDB_ERROR tdb1_parse_data(struct tdb_context *tdb, TDB_DATA key,
- tdb1_off_t offset, tdb1_len_t len,
- enum TDB_ERROR (*parser)(TDB_DATA key,
- TDB_DATA data,
- void *private_data),
- void *private_data)
-{
- TDB_DATA data;
- enum TDB_ERROR result;
-
- data.dsize = len;
-
- if ((tdb->tdb1.transaction == NULL) && (tdb->file->map_ptr != NULL)) {
- /*
- * Optimize by avoiding the malloc/memcpy/free, point the
- * parser directly at the mmap area.
- */
- if (tdb->tdb1.io->tdb1_oob(tdb, offset+len, 0) != 0) {
- return tdb->last_error;
- }
- data.dptr = offset + (unsigned char *)tdb->file->map_ptr;
- return parser(key, data, private_data);
- }
-
- if (!(data.dptr = tdb1_alloc_read(tdb, offset, len))) {
- return tdb->last_error;
- }
-
- result = parser(key, data, private_data);
- free(data.dptr);
- return result;
-}
-
-/* read/write a record */
-int tdb1_rec_read(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
-{
- if (tdb->tdb1.io->tdb1_read(tdb, offset, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
- return -1;
- if (TDB1_BAD_MAGIC(rec)) {
- 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->tdb1.io->tdb1_oob(tdb, rec->next+sizeof(*rec), 0);
-}
-
-int tdb1_rec_write(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
-{
- struct tdb1_record r = *rec;
- return tdb->tdb1.io->tdb1_write(tdb, offset, TDB1_CONV(r), sizeof(r));
-}
-
-static const struct tdb1_methods io1_methods = {
- tdb1_read,
- tdb1_write,
- tdb1_next_hash_chain,
- tdb1_oob,
- tdb1_expand_file,
-};
-
-/*
- initialise the default methods table
-*/
-void tdb1_io_init(struct tdb_context *tdb)
-{
- tdb->tdb1.io = &io1_methods;
-}
-
-enum TDB_ERROR tdb1_probe_length(struct tdb_context *tdb)
-{
- tdb->last_error = TDB_SUCCESS;
- tdb->tdb1.io->tdb1_oob(tdb, tdb->file->map_size + 1, true);
- return tdb->last_error;
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "tdb1_private.h"
-
-/* list -1 is the alloc list, otherwise a hash chain. */
-static tdb1_off_t lock_offset(int list)
-{
- return TDB1_FREELIST_TOP + 4*list;
-}
-
-/* a byte range locking function - return 0 on success
- this functions locks/unlocks 1 byte at the specified offset.
-
- On error, errno is also set so that errors are passed back properly
- through tdb1_open().
-
- note that a len of zero means lock to end of file
-*/
-int tdb1_brlock(struct tdb_context *tdb,
- int rw_type, tdb1_off_t offset, size_t len,
- enum tdb_lock_flags flags)
-{
- enum TDB_ERROR ecode = tdb_brlock(tdb, rw_type, offset, len, flags
- | TDB_LOCK_NOCHECK);
- if (ecode == TDB_SUCCESS)
- return 0;
- tdb->last_error = ecode;
- return -1;
-}
-
-int tdb1_brunlock(struct tdb_context *tdb,
- int rw_type, tdb1_off_t offset, size_t len)
-{
- enum TDB_ERROR ecode = tdb_brunlock(tdb, rw_type, offset, len);
- if (ecode == TDB_SUCCESS)
- return 0;
- tdb->last_error = ecode;
- return -1;
-}
-
-int tdb1_allrecord_upgrade(struct tdb_context *tdb)
-{
- enum TDB_ERROR ecode = tdb_allrecord_upgrade(tdb, TDB1_FREELIST_TOP);
- if (ecode == TDB_SUCCESS)
- return 0;
- tdb->last_error = ecode;
- return -1;
-}
-
-static struct tdb_lock *tdb1_find_nestlock(struct tdb_context *tdb,
- tdb1_off_t offset)
-{
- unsigned int i;
-
- for (i=0; i<tdb->file->num_lockrecs; i++) {
- if (tdb->file->lockrecs[i].off == offset) {
- return &tdb->file->lockrecs[i];
- }
- }
- return NULL;
-}
-
-/* lock an offset in the database. */
-int tdb1_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
- enum tdb_lock_flags flags)
-{
- enum TDB_ERROR ecode;
-
- if (offset >= lock_offset(tdb->tdb1.header.hash_size)) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
- "tdb1_lock: invalid offset %u for"
- " ltype=%d",
- offset, ltype);
- return -1;
- }
-
- ecode = tdb_nest_lock(tdb, offset, ltype, flags | TDB_LOCK_NOCHECK);
- if (unlikely(ecode != TDB_SUCCESS)) {
- tdb->last_error = ecode;
- return -1;
- }
- return 0;
-}
-
-static int tdb1_lock_and_recover(struct tdb_context *tdb)
-{
- int ret;
-
- /* We need to match locking order in transaction commit. */
- if (tdb1_brlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0,
- TDB_LOCK_WAIT|TDB_LOCK_NOCHECK)) {
- return -1;
- }
-
- if (tdb1_brlock(tdb, F_WRLCK, TDB1_OPEN_LOCK, 1,
- TDB_LOCK_WAIT|TDB_LOCK_NOCHECK)) {
- tdb1_brunlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0);
- return -1;
- }
-
- ret = tdb1_transaction_recover(tdb);
-
- tdb1_brunlock(tdb, F_WRLCK, TDB1_OPEN_LOCK, 1);
- tdb1_brunlock(tdb, F_WRLCK, TDB1_FREELIST_TOP, 0);
-
- return ret;
-}
-
-static bool have_data_locks(const struct tdb_context *tdb)
-{
- unsigned int i;
-
- for (i = 0; i < tdb->file->num_lockrecs; i++) {
- if (tdb->file->lockrecs[i].off >= lock_offset(-1))
- return true;
- }
- return false;
-}
-
-static int tdb1_lock_list(struct tdb_context *tdb, int list, int ltype,
- enum tdb_lock_flags waitflag)
-{
- int ret;
- bool check = false;
-
- /* a allrecord lock allows us to avoid per chain locks */
- if (tdb->file->allrecord_lock.count) {
- if (!check_lock_pid(tdb, "tdb1_lock_list", true)) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error = owner_conflict(tdb, "tdb1_lock_list");
- return -1;
- }
- if (ltype == tdb->file->allrecord_lock.ltype
- || ltype == F_RDLCK) {
- return 0;
- }
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK,
- TDB_LOG_USE_ERROR,
- "tdb1_lock_list:"
- " already have read lock");
- return -1;
- }
-
- /* Only check when we grab first data lock. */
- check = !have_data_locks(tdb);
- ret = tdb1_nest_lock(tdb, lock_offset(list), ltype, waitflag);
-
- if (ret == 0 && check) {
- tdb_bool_err berr = tdb1_needs_recovery(tdb);
-
- if (berr < 0) {
- return -1;
- }
- if (berr == true) {
- tdb1_nest_unlock(tdb, lock_offset(list), ltype);
-
- if (tdb1_lock_and_recover(tdb) == -1) {
- return -1;
- }
- return tdb1_lock_list(tdb, list, ltype, waitflag);
- }
- }
- return ret;
-}
-
-/* lock a list in the database. list -1 is the alloc list */
-int tdb1_lock(struct tdb_context *tdb, int list, int ltype)
-{
- int ret;
-
- ret = tdb1_lock_list(tdb, list, ltype, TDB_LOCK_WAIT);
- /* Don't log for EAGAIN and EINTR: they could have overridden lock fns */
- if (ret && errno != EAGAIN && errno != EINTR) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_lock failed on list %d "
- "ltype=%d (%s)", list, ltype, strerror(errno));
- }
- return ret;
-}
-
-int tdb1_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype)
-{
- enum TDB_ERROR ecode;
-
- /* Sanity checks */
- if (offset >= lock_offset(tdb->tdb1.header.hash_size)) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
- "tdb1_unlock: offset %u invalid (%d)",
- offset, tdb->tdb1.header.hash_size);
- return -1;
- }
-
- ecode = tdb_nest_unlock(tdb, offset, ltype);
- if (unlikely(ecode != TDB_SUCCESS)) {
- tdb->last_error = ecode;
- return -1;
- }
- return 0;
-}
-
-int tdb1_unlock(struct tdb_context *tdb, int list, int ltype)
-{
- /* a global lock allows us to avoid per chain locks */
- if (tdb->file->allrecord_lock.count &&
- (ltype == tdb->file->allrecord_lock.ltype || ltype == F_RDLCK)) {
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error = owner_conflict(tdb, "tdb1_unlock");
- return -1;
- }
- return 0;
- }
-
- if (tdb->file->allrecord_lock.count) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
-
- return tdb1_nest_unlock(tdb, lock_offset(list), ltype);
-}
-
-/*
- get the transaction lock
- */
-int tdb1_transaction_lock(struct tdb_context *tdb, int ltype,
- enum tdb_lock_flags lockflags)
-{
- return tdb1_nest_lock(tdb, TDB1_TRANSACTION_LOCK, ltype, lockflags);
-}
-
-/*
- release the transaction lock
- */
-int tdb1_transaction_unlock(struct tdb_context *tdb, int ltype)
-{
- return tdb1_nest_unlock(tdb, TDB1_TRANSACTION_LOCK, ltype);
-}
-
-/* lock/unlock entire database. It can only be upgradable if you have some
- * other way of guaranteeing exclusivity (ie. transaction write lock).
- * We do the locking gradually to avoid being starved by smaller locks. */
-int tdb1_allrecord_lock(struct tdb_context *tdb, int ltype,
- enum tdb_lock_flags flags, bool upgradable)
-{
- enum TDB_ERROR ecode;
- tdb_bool_err berr;
-
- /* tdb_lock_gradual() doesn't know about tdb->tdb1.traverse_read. */
- if (tdb->tdb1.traverse_read && !(tdb->flags & TDB_NOLOCK)) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK,
- TDB_LOG_USE_ERROR,
- "tdb1_allrecord_lock during"
- " tdb1_read_traverse");
- return -1;
- }
-
- if (tdb->file->allrecord_lock.count
- && tdb->file->allrecord_lock.ltype == ltype) {
- tdb->file->allrecord_lock.count++;
- return 0;
- }
-
- if (tdb1_have_extra_locks(tdb)) {
- /* can't combine global and chain locks */
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK,
- TDB_LOG_USE_ERROR,
- "tdb1_allrecord_lock holding"
- " other locks");
- return -1;
- }
-
- if (upgradable && ltype != F_RDLCK) {
- /* tdb error: you can't upgrade a write lock! */
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_LOCK,
- TDB_LOG_ERROR,
- "tdb1_allrecord_lock cannot"
- " have upgradable write lock");
- return -1;
- }
-
- /* We cover two kinds of locks:
- * 1) Normal chain locks. Taken for almost all operations.
- * 3) Individual records locks. Taken after normal or free
- * chain locks.
- *
- * It is (1) which cause the starvation problem, so we're only
- * gradual for that. */
- ecode = tdb_lock_gradual(tdb, ltype, flags | TDB_LOCK_NOCHECK,
- TDB1_FREELIST_TOP, tdb->tdb1.header.hash_size * 4);
- if (ecode != TDB_SUCCESS) {
- tdb->last_error = ecode;
- return -1;
- }
-
- /* Grab individual record locks. */
- if (tdb1_brlock(tdb, ltype, lock_offset(tdb->tdb1.header.hash_size), 0,
- flags) == -1) {
- tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP,
- tdb->tdb1.header.hash_size * 4);
- return -1;
- }
-
- tdb->file->allrecord_lock.owner = tdb;
- tdb->file->allrecord_lock.count = 1;
- tdb->file->locker = getpid();
- /* If it's upgradable, it's actually exclusive so we can treat
- * it as a write lock. */
- tdb->file->allrecord_lock.ltype = upgradable ? F_WRLCK : ltype;
- tdb->file->allrecord_lock.off = upgradable;
-
- berr = tdb1_needs_recovery(tdb);
- if (berr < 0) {
- return -1;
- }
-
- if (berr == true) {
- tdb1_allrecord_unlock(tdb, ltype);
- if (tdb1_lock_and_recover(tdb) == -1) {
- return -1;
- }
- return tdb1_allrecord_lock(tdb, ltype, flags, upgradable);
- }
-
- return 0;
-}
-
-
-
-/* unlock entire db */
-int tdb1_allrecord_unlock(struct tdb_context *tdb, int ltype)
-{
- /* Don't try this during r/o traversal! */
- if (tdb->tdb1.traverse_read) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
-
- if (tdb->file->allrecord_lock.count == 0) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
-
- /* Upgradable locks are marked as write locks. */
- if (tdb->file->allrecord_lock.ltype != ltype
- && (!tdb->file->allrecord_lock.off || ltype != F_RDLCK)) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
-
- if (tdb->file->allrecord_lock.count > 1) {
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error
- = owner_conflict(tdb, "tdb1_allrecord_unlock");
- return -1;
- }
- tdb->file->allrecord_lock.count--;
- return 0;
- }
-
- tdb->file->allrecord_lock.count = 0;
- tdb->file->allrecord_lock.ltype = 0;
-
- if (tdb1_brunlock(tdb, ltype, TDB1_FREELIST_TOP, 0)) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_unlockall failed (%s)", strerror(errno));
- return -1;
- }
-
- return 0;
-}
-
-/* lock/unlock one hash chain. This is meant to be used to reduce
- contention - it cannot guarantee how many records will be locked */
-int tdb1_chainlock(struct tdb_context *tdb, TDB_DATA key)
-{
- int ret = tdb1_lock(tdb,
- TDB1_BUCKET(tdb_hash(tdb, key.dptr, key.dsize)),
- F_WRLCK);
- return ret;
-}
-
-int tdb1_chainunlock(struct tdb_context *tdb, TDB_DATA key)
-{
- return tdb1_unlock(tdb, TDB1_BUCKET(tdb_hash(tdb, key.dptr, key.dsize)),
- F_WRLCK);
-}
-
-int tdb1_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
-{
- int ret;
- ret = tdb1_lock(tdb, TDB1_BUCKET(tdb_hash(tdb, key.dptr, key.dsize)),
- F_RDLCK);
- return ret;
-}
-
-int tdb1_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
-{
- return tdb1_unlock(tdb, TDB1_BUCKET(tdb_hash(tdb, key.dptr, key.dsize)),
- F_RDLCK);
-}
-
-/* record lock stops delete underneath */
-int tdb1_lock_record(struct tdb_context *tdb, tdb1_off_t off)
-{
- if (tdb->file->allrecord_lock.count) {
- if (!check_lock_pid(tdb, "tdb1_lock_record", true)) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error = owner_conflict(tdb,
- "tdb1_lock_record");
- return -1;
- }
- return 0;
- }
- return off ? tdb1_brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0;
-}
-
-/*
- Write locks override our own fcntl readlocks, so check it here.
- Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
- an error to fail to get the lock here.
-*/
-int tdb1_write_lock_record(struct tdb_context *tdb, tdb1_off_t off)
-{
- struct tdb1_traverse_lock *i;
- for (i = &tdb->tdb1.travlocks; i; i = i->next)
- if (i->off == off)
- return -1;
- if (tdb->file->allrecord_lock.count) {
- if (!check_lock_pid(tdb, "tdb1_write_lock_record", true)) {
- tdb->last_error = TDB_ERR_LOCK;
- return -1;
- }
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error
- = owner_conflict(tdb, "tdb1_write_lock_record");
- return -1;
- }
- if (tdb->file->allrecord_lock.ltype == F_WRLCK) {
- return 0;
- }
- return -1;
- }
- return tdb1_brlock(tdb, F_WRLCK, off, 1, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE);
-}
-
-int tdb1_write_unlock_record(struct tdb_context *tdb, tdb1_off_t off)
-{
- if (tdb->file->allrecord_lock.count) {
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error
- = owner_conflict(tdb,
- "tdb1_write_unlock_record");
- return -1;
- }
- return 0;
- }
- return tdb1_brunlock(tdb, F_WRLCK, off, 1);
-}
-
-/* fcntl locks don't stack: avoid unlocking someone else's */
-int tdb1_unlock_record(struct tdb_context *tdb, tdb1_off_t off)
-{
- struct tdb1_traverse_lock *i;
- uint32_t count = 0;
-
- if (tdb->file->allrecord_lock.count) {
- if (tdb->file->allrecord_lock.owner != tdb) {
- tdb->last_error = owner_conflict(tdb,
- "tdb1_unlock_record");
- return -1;
- }
- return 0;
- }
-
- if (off == 0)
- return 0;
- for (i = &tdb->tdb1.travlocks; i; i = i->next)
- if (i->off == off)
- count++;
- return (count == 1 ? tdb1_brunlock(tdb, F_RDLCK, off, 1) : 0);
-}
-
-bool tdb1_have_extra_locks(struct tdb_context *tdb)
-{
- unsigned int extra = tdb->file->num_lockrecs;
-
- /* A transaction holds the lock for all records. */
- if (!tdb->tdb1.transaction && tdb->file->allrecord_lock.count) {
- return true;
- }
-
- /* We always hold the active lock if CLEAR_IF_FIRST. */
- if (tdb1_find_nestlock(tdb, TDB1_ACTIVE_LOCK)) {
- extra--;
- }
-
- /* In a transaction, we expect to hold the transaction lock */
- if (tdb->tdb1.transaction
- && tdb1_find_nestlock(tdb, TDB1_TRANSACTION_LOCK)) {
- extra--;
- }
-
- return extra;
-}
-
-/* The transaction code uses this to remove all locks. */
-void tdb1_release_transaction_locks(struct tdb_context *tdb)
-{
- unsigned int i, active = 0;
-
- if (tdb->file->allrecord_lock.count != 0) {
- tdb1_brunlock(tdb, tdb->file->allrecord_lock.ltype, TDB1_FREELIST_TOP, 0);
- tdb->file->allrecord_lock.count = 0;
- }
-
- for (i=0;i<tdb->file->num_lockrecs;i++) {
- struct tdb_lock *lck = &tdb->file->lockrecs[i];
-
- /* Don't release the active lock! Copy it to first entry. */
- if (lck->off == TDB1_ACTIVE_LOCK) {
- tdb->file->lockrecs[active++] = *lck;
- } else {
- tdb1_brunlock(tdb, lck->ltype, lck->off, 1);
- }
- }
- tdb->file->num_lockrecs = active;
- if (tdb->file->num_lockrecs == 0) {
- SAFE_FREE(tdb->file->lockrecs);
- }
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#include <assert.h>
-#include "tdb1_private.h"
-#include <assert.h>
-
-/* We use two hashes to double-check they're using the right hash function. */
-void tdb1_header_hash(struct tdb_context *tdb,
- uint32_t *magic1_hash, uint32_t *magic2_hash)
-{
- uint32_t tdb1_magic = TDB1_MAGIC;
-
- *magic1_hash = tdb_hash(tdb, TDB_MAGIC_FOOD, sizeof(TDB_MAGIC_FOOD));
- *magic2_hash = tdb_hash(tdb, TDB1_CONV(tdb1_magic), sizeof(tdb1_magic));
-
- /* Make sure at least one hash is non-zero! */
- if (*magic1_hash == 0 && *magic2_hash == 0)
- *magic1_hash = 1;
-}
-
-static void tdb_context_init(struct tdb_context *tdb,
- struct tdb_attribute_tdb1_max_dead *max_dead)
-{
- assert(tdb->flags & TDB_VERSION1);
-
- tdb1_io_init(tdb);
-
- tdb->tdb1.traverse_read = tdb->tdb1.traverse_write = 0;
- memset(&tdb->tdb1.travlocks, 0, sizeof(tdb->tdb1.travlocks));
- tdb->tdb1.transaction = NULL;
-
- /* cache the page size */
- tdb->tdb1.page_size = getpagesize();
- if (tdb->tdb1.page_size <= 0) {
- tdb->tdb1.page_size = 0x2000;
- }
-
- if (max_dead) {
- tdb->tdb1.max_dead_records = max_dead->max_dead;
- } else {
- tdb->tdb1.max_dead_records = 0;
- }
-}
-
-/* initialise a new database */
-enum TDB_ERROR tdb1_new_database(struct tdb_context *tdb,
- struct tdb_attribute_tdb1_hashsize *hashsize,
- struct tdb_attribute_tdb1_max_dead *max_dead)
-{
- struct tdb1_header *newdb;
- size_t size;
- int hash_size = TDB1_DEFAULT_HASH_SIZE;
- enum TDB_ERROR ret;
-
- tdb_context_init(tdb, max_dead);
-
- /* Default TDB2 hash becomes default TDB1 hash. */
- if (tdb->hash_fn == tdb_jenkins_hash)
- tdb->hash_fn = tdb1_old_hash;
-
- if (hashsize)
- hash_size = hashsize->hsize;
-
- /* 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))) {
- return tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
- "Could not allocate new database header");
- }
-
- /* Fill in the header */
- newdb->version = TDB1_VERSION;
- newdb->hash_size = hash_size;
-
- tdb1_header_hash(tdb, &newdb->magic1_hash, &newdb->magic2_hash);
-
- /* Make sure older tdbs (which don't check the magic hash fields)
- * will refuse to open this TDB. */
- if (tdb->hash_fn == tdb1_incompatible_hash)
- newdb->rwlocks = TDB1_HASH_RWLOCK_MAGIC;
-
- memcpy(&tdb->tdb1.header, newdb, sizeof(tdb->tdb1.header));
- /* This creates an endian-converted db. */
- TDB1_CONV(*newdb);
- /* Don't endian-convert the magic food! */
- memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
-
- if (tdb->flags & TDB_INTERNAL) {
- tdb->file->map_size = size;
- tdb->file->map_ptr = (char *)newdb;
- return TDB_SUCCESS;
- }
- if (lseek(tdb->file->fd, 0, SEEK_SET) == -1) {
- ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_new_database: lseek failed");
- goto fail;
- }
-
- if (ftruncate(tdb->file->fd, 0) == -1) {
- ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_new_database: ftruncate failed");
- goto fail;
- }
-
- if (!tdb1_write_all(tdb->file->fd, newdb, size)) {
- ret = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_new_database: write failed");
- goto fail;
- }
- ret = TDB_SUCCESS;
-
- fail:
- SAFE_FREE(newdb);
- return ret;
-}
-
-typedef void (*tdb1_log_func)(struct tdb_context *, enum tdb_log_level, enum TDB_ERROR,
- const char *, void *);
-typedef uint64_t (*tdb1_hash_func)(const void *key, size_t len, uint64_t seed,
- void *data);
-
-struct tdb1_logging_context {
- tdb1_log_func log_fn;
- void *log_private;
-};
-
-static bool hash_correct(struct tdb_context *tdb,
- uint32_t *m1, uint32_t *m2)
-{
- /* older TDB without magic hash references */
- if (tdb->tdb1.header.magic1_hash == 0
- && tdb->tdb1.header.magic2_hash == 0) {
- return true;
- }
-
- tdb1_header_hash(tdb, m1, m2);
- return (tdb->tdb1.header.magic1_hash == *m1 &&
- tdb->tdb1.header.magic2_hash == *m2);
-}
-
-static bool check_header_hash(struct tdb_context *tdb,
- uint32_t *m1, uint32_t *m2)
-{
- if (hash_correct(tdb, m1, m2))
- return true;
-
- /* If they use one inbuilt, try the other inbuilt hash. */
- if (tdb->hash_fn == tdb1_old_hash)
- tdb->hash_fn = tdb1_incompatible_hash;
- else if (tdb->hash_fn == tdb1_incompatible_hash)
- tdb->hash_fn = tdb1_old_hash;
- else
- return false;
- return hash_correct(tdb, m1, m2);
-}
-
-/* We are hold the TDB open lock on tdb->fd. */
-enum TDB_ERROR tdb1_open(struct tdb_context *tdb,
- struct tdb_attribute_tdb1_max_dead *max_dead)
-{
- const char *hash_alg;
- uint32_t magic1, magic2;
-
- tdb->flags |= TDB_VERSION1;
-
- tdb_context_init(tdb, max_dead);
-
- /* Default TDB2 hash becomes default TDB1 hash. */
- if (tdb->hash_fn == tdb_jenkins_hash) {
- tdb->hash_fn = tdb1_old_hash;
- hash_alg = "default";
- } else if (tdb->hash_fn == tdb1_incompatible_hash)
- hash_alg = "tdb1_incompatible_hash";
- else
- hash_alg = "the user defined";
-
- if (tdb->tdb1.header.version != TDB1_BYTEREV(TDB1_VERSION)) {
- if (tdb->flags & TDB_CONVERT) {
- return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_open:"
- " %s does not need TDB_CONVERT",
- tdb->name);
- }
- } else {
- tdb->flags |= TDB_CONVERT;
- tdb1_convert(&tdb->tdb1.header, sizeof(tdb->tdb1.header));
- }
-
- if (tdb->tdb1.header.rwlocks != 0 &&
- tdb->tdb1.header.rwlocks != TDB1_HASH_RWLOCK_MAGIC) {
- return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "tdb1_open: spinlocks no longer supported");
- }
-
- if (!check_header_hash(tdb, &magic1, &magic2)) {
- return tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_USE_ERROR,
- "tdb1_open: "
- "%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]",
- tdb->name, hash_alg,
- tdb->tdb1.header.magic1_hash,
- (tdb->tdb1.header.magic1_hash == magic1) ? "==" : "!=",
- magic1,
- tdb->tdb1.header.magic2_hash,
- (tdb->tdb1.header.magic2_hash == magic2) ? "==" : "!=",
- magic2);
- }
- return TDB_SUCCESS;
-}
+++ /dev/null
-#ifndef CCAN_TDB2_TDB1_PRIVATE_H
-#define CCAN_TDB2_TDB1_PRIVATE_H
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library - private includes
-
- Copyright (C) Andrew Tridgell 2005
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "private.h"
-
-#include <limits.h>
-
-/* #define TDB_TRACE 1 */
-#ifndef HAVE_GETPAGESIZE
-#define getpagesize() 0x2000
-#endif
-
-#ifndef __STRING
-#define __STRING(x) #x
-#endif
-
-#ifndef __STRINGSTRING
-#define __STRINGSTRING(x) __STRING(x)
-#endif
-
-#ifndef __location__
-#define __location__ __FILE__ ":" __STRINGSTRING(__LINE__)
-#endif
-
-#ifndef offsetof
-#define offsetof(t,f) ((unsigned int)&((t *)0)->f)
-#endif
-
-#define TDB1_VERSION (0x26011967 + 6)
-#define TDB1_MAGIC (0x26011999U)
-#define TDB1_FREE_MAGIC (~TDB1_MAGIC)
-#define TDB1_DEAD_MAGIC (0xFEE1DEAD)
-#define TDB1_RECOVERY_MAGIC (0xf53bc0e7U)
-#define TDB1_RECOVERY_INVALID_MAGIC (0x0)
-#define TDB1_HASH_RWLOCK_MAGIC (0xbad1a51U)
-#define TDB1_ALIGNMENT 4
-#define TDB1_DEFAULT_HASH_SIZE 131
-#define TDB1_FREELIST_TOP (sizeof(struct tdb1_header))
-#define TDB1_ALIGN(x,a) (((x) + (a)-1) & ~((a)-1))
-#define TDB1_DEAD(r) ((r)->magic == TDB1_DEAD_MAGIC)
-#define TDB1_BAD_MAGIC(r) ((r)->magic != TDB1_MAGIC && !TDB1_DEAD(r))
-#define TDB1_HASH_TOP(hash) (TDB1_FREELIST_TOP + (TDB1_BUCKET(hash)+1)*sizeof(tdb1_off_t))
-#define TDB1_HASHTABLE_SIZE(tdb) ((tdb->tdb1.header.hash_size+1)*sizeof(tdb1_off_t))
-#define TDB1_DATA_START(hash_size) (TDB1_HASH_TOP(hash_size-1) + sizeof(tdb1_off_t))
-#define TDB1_RECOVERY_HEAD offsetof(struct tdb1_header, recovery_start)
-#define TDB1_SEQNUM_OFS offsetof(struct tdb1_header, sequence_number)
-#define TDB1_PAD_BYTE 0x42
-#define TDB1_PAD_U32 0x42424242
-
-/* lock offsets */
-#define TDB1_OPEN_LOCK 0
-#define TDB1_ACTIVE_LOCK 4
-#define TDB1_TRANSACTION_LOCK 8
-
-/* free memory if the pointer is valid and zero the pointer */
-#ifndef SAFE_FREE
-#define SAFE_FREE(x) do { if ((x) != NULL) {free((void *)x); (x)=NULL;} } while(0)
-#endif
-
-#define TDB1_BUCKET(hash) ((hash) % tdb->tdb1.header.hash_size)
-
-#define TDB1_DOCONV() (tdb->flags & TDB_CONVERT)
-#define TDB1_CONV(x) (TDB1_DOCONV() ? tdb1_convert(&x, sizeof(x)) : &x)
-
-/* the body of the database is made of one tdb1_record for the free space
- plus a separate data list for each hash value */
-struct tdb1_record {
- tdb1_off_t next; /* offset of the next record in the list */
- tdb1_len_t rec_len; /* total byte length of record */
- tdb1_len_t key_len; /* byte length of key */
- tdb1_len_t data_len; /* byte length of data */
- uint32_t full_hash; /* the full 32 bit hash of the key */
- uint32_t magic; /* try to catch errors */
- /* the following union is implied:
- union {
- char record[rec_len];
- struct {
- char key[key_len];
- char data[data_len];
- }
- uint32_t totalsize; (tailer)
- }
- */
-};
-
-
-struct tdb1_methods {
- int (*tdb1_read)(struct tdb_context *, tdb1_off_t , void *, tdb1_len_t , int );
- int (*tdb1_write)(struct tdb_context *, tdb1_off_t, const void *, tdb1_len_t);
- void (*next_hash_chain)(struct tdb_context *, uint32_t *);
- int (*tdb1_oob)(struct tdb_context *, tdb1_off_t , int );
- int (*tdb1_expand_file)(struct tdb_context *, tdb1_off_t , tdb1_off_t );
-};
-
-
-/*
- internal prototypes
-*/
-int tdb1_munmap(struct tdb_context *tdb);
-int tdb1_mmap(struct tdb_context *tdb);
-int tdb1_lock(struct tdb_context *tdb, int list, int ltype);
-int tdb1_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
- enum tdb_lock_flags flags);
-int tdb1_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype);
-int tdb1_unlock(struct tdb_context *tdb, int list, int ltype);
-int tdb1_brlock(struct tdb_context *tdb,
- int rw_type, tdb1_off_t offset, size_t len,
- enum tdb_lock_flags flags);
-int tdb1_brunlock(struct tdb_context *tdb,
- int rw_type, tdb1_off_t offset, size_t len);
-bool tdb1_have_extra_locks(struct tdb_context *tdb);
-void tdb1_release_transaction_locks(struct tdb_context *tdb);
-int tdb1_transaction_lock(struct tdb_context *tdb, int ltype,
- enum tdb_lock_flags lockflags);
-int tdb1_transaction_unlock(struct tdb_context *tdb, int ltype);
-int tdb1_recovery_area(struct tdb_context *tdb,
- const struct tdb1_methods *methods,
- tdb1_off_t *recovery_offset,
- struct tdb1_record *rec);
-int tdb1_allrecord_upgrade(struct tdb_context *tdb);
-int tdb1_write_lock_record(struct tdb_context *tdb, tdb1_off_t off);
-int tdb1_write_unlock_record(struct tdb_context *tdb, tdb1_off_t off);
-int tdb1_ofs_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d);
-int tdb1_ofs_write(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d);
-void *tdb1_convert(void *buf, uint32_t size);
-int tdb1_free(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec);
-tdb1_off_t tdb1_allocate(struct tdb_context *tdb, tdb1_len_t length, struct tdb1_record *rec);
-int tdb1_ofs_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d);
-int tdb1_ofs_write(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d);
-int tdb1_lock_record(struct tdb_context *tdb, tdb1_off_t off);
-int tdb1_unlock_record(struct tdb_context *tdb, tdb1_off_t off);
-tdb_bool_err tdb1_needs_recovery(struct tdb_context *tdb);
-int tdb1_rec_read(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec);
-int tdb1_rec_write(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec);
-int tdb1_do_delete(struct tdb_context *tdb, tdb1_off_t rec_ptr, struct tdb1_record *rec);
-unsigned char *tdb1_alloc_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_len_t len);
-enum TDB_ERROR tdb1_parse_data(struct tdb_context *tdb, TDB_DATA key,
- tdb1_off_t offset, tdb1_len_t len,
- enum TDB_ERROR (*parser)(TDB_DATA key,
- TDB_DATA data,
- void *private_data),
- void *private_data);
-tdb1_off_t tdb1_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
- struct tdb1_record *rec);
-void tdb1_io_init(struct tdb_context *tdb);
-int tdb1_expand(struct tdb_context *tdb, tdb1_off_t size);
-int tdb1_rec_free_read(struct tdb_context *tdb, tdb1_off_t off,
- struct tdb1_record *rec);
-bool tdb1_write_all(int fd, const void *buf, size_t count);
-void tdb1_header_hash(struct tdb_context *tdb,
- uint32_t *magic1_hash, uint32_t *magic2_hash);
-uint64_t tdb1_old_hash(const void *key, size_t len, uint64_t seed, void *);
-size_t tdb1_dead_space(struct tdb_context *tdb, tdb1_off_t off);
-#endif /* CCAN_TDB2_TDB1_PRIVATE_H */
+++ /dev/null
- /*
- Trivial Database: human-readable summary code
- Copyright (C) Rusty Russell 2010
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-#include "tdb1_private.h"
-
-#define SUMMARY_FORMAT1 \
- "Size of file/data: %u/%zu\n" \
- "Number of records: %zu\n" \
- "Smallest/average/largest keys: %zu/%zu/%zu\n" \
- "Smallest/average/largest data: %zu/%zu/%zu\n" \
- "Smallest/average/largest padding: %zu/%zu/%zu\n" \
- "Number of dead records: %zu\n" \
- "Smallest/average/largest dead records: %zu/%zu/%zu\n" \
- "Number of free records: %zu\n" \
- "Smallest/average/largest free records: %zu/%zu/%zu\n" \
- "Number of hash chains: %zu\n" \
- "Smallest/average/largest hash chains: %zu/%zu/%zu\n" \
- "Number of uncoalesced records: %zu\n" \
- "Smallest/average/largest uncoalesced runs: %zu/%zu/%zu\n" \
- "Percentage keys/data/padding/free/dead/rechdrs&tailers/hashes: %.0f/%.0f/%.0f/%.0f/%.0f/%.0f/%.0f\n"
-
-/* We don't use tally module, to keep upstream happy. */
-struct tally {
- size_t min, max, total;
- size_t num;
-};
-
-static void tally1_init(struct tally *tally)
-{
- tally->total = 0;
- tally->num = 0;
- tally->min = tally->max = 0;
-}
-
-static void tally1_add(struct tally *tally, size_t len)
-{
- if (tally->num == 0)
- tally->max = tally->min = len;
- else if (len > tally->max)
- tally->max = len;
- else if (len < tally->min)
- tally->min = len;
- tally->num++;
- tally->total += len;
-}
-
-static size_t tally1_mean(const struct tally *tally)
-{
- if (!tally->num)
- return 0;
- return tally->total / tally->num;
-}
-
-static size_t get_hash_length(struct tdb_context *tdb, unsigned int i)
-{
- tdb1_off_t rec_ptr;
- size_t count = 0;
-
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(i), &rec_ptr) == -1)
- return 0;
-
- /* keep looking until we find the right record */
- while (rec_ptr) {
- struct tdb1_record r;
- ++count;
- if (tdb1_rec_read(tdb, rec_ptr, &r) == -1)
- return 0;
- rec_ptr = r.next;
- }
- return count;
-}
-
-char *tdb1_summary(struct tdb_context *tdb)
-{
- tdb1_off_t off, rec_off;
- struct tally freet, keys, data, dead, extra, hash, uncoal;
- struct tdb1_record rec;
- char *ret = NULL;
- bool locked;
- size_t len, unc = 0;
- struct tdb1_record recovery;
-
- /* We may have a write lock already, so don't lock. */
- if (tdb->file->allrecord_lock.count != 0) {
- locked = false;
- } else {
- if (tdb_lockall_read(tdb) != TDB_SUCCESS)
- return NULL;
- locked = true;
- }
-
- if (tdb1_recovery_area(tdb, tdb->tdb1.io, &rec_off, &recovery) != 0) {
- goto unlock;
- }
-
- tally1_init(&freet);
- tally1_init(&keys);
- tally1_init(&data);
- tally1_init(&dead);
- tally1_init(&extra);
- tally1_init(&hash);
- tally1_init(&uncoal);
-
- for (off = TDB1_DATA_START(tdb->tdb1.header.hash_size);
- off < tdb->file->map_size - 1;
- off += sizeof(rec) + rec.rec_len) {
- if (tdb->tdb1.io->tdb1_read(tdb, off, &rec, sizeof(rec),
- TDB1_DOCONV()) == -1)
- goto unlock;
- switch (rec.magic) {
- case TDB1_MAGIC:
- tally1_add(&keys, rec.key_len);
- tally1_add(&data, rec.data_len);
- tally1_add(&extra, rec.rec_len - (rec.key_len
- + rec.data_len));
- if (unc > 1)
- tally1_add(&uncoal, unc - 1);
- unc = 0;
- break;
- case TDB1_FREE_MAGIC:
- tally1_add(&freet, rec.rec_len);
- unc++;
- break;
- /* If we crash after ftruncate, we can get zeroes or fill. */
- case TDB1_RECOVERY_INVALID_MAGIC:
- case 0x42424242:
- unc++;
- /* If it's a valid recovery, we can trust rec_len. */
- if (off != rec_off) {
- rec.rec_len = tdb1_dead_space(tdb, off)
- - sizeof(rec);
- }
- /* Fall through */
- case TDB1_DEAD_MAGIC:
- tally1_add(&dead, rec.rec_len);
- break;
- default:
- 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;
- }
- }
- if (unc > 1)
- tally1_add(&uncoal, unc - 1);
-
- for (off = 0; off < tdb->tdb1.header.hash_size; off++)
- tally1_add(&hash, get_hash_length(tdb, off));
-
- /* 20 is max length of a %zu. */
- len = strlen(SUMMARY_FORMAT1) + 35*20 + 1;
- ret = (char *)malloc(len);
- if (!ret)
- goto unlock;
-
- snprintf(ret, len, SUMMARY_FORMAT1,
- (tdb1_len_t)tdb->file->map_size, keys.total+data.total,
- keys.num,
- keys.min, tally1_mean(&keys), keys.max,
- data.min, tally1_mean(&data), data.max,
- extra.min, tally1_mean(&extra), extra.max,
- dead.num,
- dead.min, tally1_mean(&dead), dead.max,
- freet.num,
- freet.min, tally1_mean(&freet), freet.max,
- hash.num,
- hash.min, tally1_mean(&hash), hash.max,
- uncoal.total,
- uncoal.min, tally1_mean(&uncoal), uncoal.max,
- keys.total * 100.0 / tdb->file->map_size,
- data.total * 100.0 / tdb->file->map_size,
- extra.total * 100.0 / tdb->file->map_size,
- freet.total * 100.0 / tdb->file->map_size,
- dead.total * 100.0 / tdb->file->map_size,
- (keys.num + freet.num + dead.num)
- * (sizeof(struct tdb1_record) + sizeof(uint32_t))
- * 100.0 / tdb->file->map_size,
- tdb->tdb1.header.hash_size * sizeof(tdb1_off_t)
- * 100.0 / (tdb1_len_t)tdb->file->map_size);
-
-unlock:
- if (locked) {
- tdb_unlockall_read(tdb);
- }
- return ret;
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "tdb1_private.h"
-#include <assert.h>
-
-/*
- non-blocking increment of the tdb sequence number if the tdb has been opened using
- the TDB_SEQNUM flag
-*/
-void tdb1_increment_seqnum_nonblock(struct tdb_context *tdb)
-{
- tdb1_off_t seqnum=0;
-
- if (!(tdb->flags & TDB_SEQNUM)) {
- return;
- }
-
- /* we ignore errors from this, as we have no sane way of
- dealing with them.
- */
- tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
- seqnum++;
- tdb1_ofs_write(tdb, TDB1_SEQNUM_OFS, &seqnum);
-}
-
-/*
- increment the tdb sequence number if the tdb has been opened using
- the TDB_SEQNUM flag
-*/
-static void tdb1_increment_seqnum(struct tdb_context *tdb)
-{
- if (!(tdb->flags & TDB_SEQNUM)) {
- return;
- }
-
- if (tdb1_nest_lock(tdb, TDB1_SEQNUM_OFS, F_WRLCK,
- TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
- return;
- }
-
- tdb1_increment_seqnum_nonblock(tdb);
-
- tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
-}
-
-static enum TDB_ERROR tdb1_key_compare(TDB_DATA key, TDB_DATA data,
- void *matches_)
-{
- bool *matches = matches_;
- *matches = (memcmp(data.dptr, key.dptr, data.dsize) == 0);
- return TDB_SUCCESS;
-}
-
-/* Returns 0 on fail; last_error will be TDB_ERR_NOEXIST if it simply
- * wasn't there, otherwise a real error.
- * On success, return offset of record, and fills in rec */
-static tdb1_off_t tdb1_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
- struct tdb1_record *r)
-{
- tdb1_off_t rec_ptr;
-
- /* read in the hash top */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
- return 0;
-
- /* keep looking until we find the right record */
- while (rec_ptr) {
- if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
- return 0;
-
- tdb->stats.compares++;
- if (TDB1_DEAD(r)) {
- tdb->stats.compare_wrong_bucket++;
- } else if (key.dsize != r->key_len) {
- tdb->stats.compare_wrong_keylen++;
- } else if (hash != r->full_hash) {
- tdb->stats.compare_wrong_rechash++;
- } else {
- enum TDB_ERROR ecode;
- bool matches;
- ecode = tdb1_parse_data(tdb, key, rec_ptr + sizeof(*r),
- r->key_len, tdb1_key_compare,
- &matches);
-
- if (ecode != TDB_SUCCESS) {
- tdb->last_error = ecode;
- return 0;
- }
-
- if (!matches) {
- tdb->stats.compare_wrong_keycmp++;
- } else {
- return rec_ptr;
- }
- }
- /* detect tight infinite loop */
- if (rec_ptr == r->next) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
- TDB_LOG_ERROR,
- "tdb1_find: loop detected.");
- return 0;
- }
- rec_ptr = r->next;
- }
- tdb->last_error = TDB_ERR_NOEXIST;
- return 0;
-}
-
-/* As tdb1_find, but if you succeed, keep the lock */
-tdb1_off_t tdb1_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
- struct tdb1_record *rec)
-{
- uint32_t rec_ptr;
-
- if (tdb1_lock(tdb, TDB1_BUCKET(hash), locktype) == -1)
- return 0;
- if (!(rec_ptr = tdb1_find(tdb, key, hash, rec)))
- tdb1_unlock(tdb, TDB1_BUCKET(hash), locktype);
- return rec_ptr;
-}
-
-static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key);
-
-static enum TDB_ERROR tdb_update_hash_cmp(TDB_DATA key, TDB_DATA data, void *private_data)
-{
- TDB_DATA *dbuf = (TDB_DATA *)private_data;
-
- if (dbuf->dsize != data.dsize) {
- return TDB_ERR_EINVAL;
- }
- if (memcmp(dbuf->dptr, data.dptr, data.dsize) != 0) {
- return TDB_ERR_EINVAL;
- }
- return TDB_SUCCESS;
-}
-
-/* update an entry in place - this only works if the new data size
- is <= the old data size and the key exists.
- on failure return -1.
-*/
-static int tdb1_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
-{
- struct tdb1_record rec;
- tdb1_off_t rec_ptr;
-
- /* find entry */
- if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec)))
- return -1;
-
- /* it could be an exact duplicate of what is there - this is
- * surprisingly common (eg. with a ldb re-index). */
- if (rec.key_len == key.dsize &&
- rec.data_len == dbuf.dsize &&
- rec.full_hash == hash &&
- tdb1_parse_record(tdb, key, tdb_update_hash_cmp, &dbuf) == TDB_SUCCESS) {
- return 0;
- }
-
- /* must be long enough key, data and tailer */
- if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb1_off_t)) {
- tdb->last_error = TDB_SUCCESS; /* Not really an error */
- return -1;
- }
-
- if (tdb->tdb1.io->tdb1_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
- dbuf.dptr, dbuf.dsize) == -1)
- return -1;
-
- if (dbuf.dsize != rec.data_len) {
- /* update size */
- rec.data_len = dbuf.dsize;
- return tdb1_rec_write(tdb, rec_ptr, &rec);
- }
-
- return 0;
-}
-
-/* find an entry in the database given a key */
-/* If an entry doesn't exist tdb1_err will be set to
- * TDB_ERR_NOEXIST. If a key has no data attached
- * then the TDB_DATA will have zero length but
- * a non-zero pointer
- */
-static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key)
-{
- tdb1_off_t rec_ptr;
- struct tdb1_record rec;
- TDB_DATA ret;
- uint32_t hash;
-
- /* find which hash bucket it is in */
- hash = tdb_hash(tdb, key.dptr, key.dsize);
- if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
- ret.dptr = NULL;
- ret.dsize = 0;
- return ret;
- }
-
- ret.dptr = tdb1_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
- rec.data_len);
- ret.dsize = rec.data_len;
- tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
- return ret;
-}
-
-enum TDB_ERROR tdb1_fetch(struct tdb_context *tdb, TDB_DATA key, TDB_DATA *data)
-{
- *data = _tdb1_fetch(tdb, key);
- if (data->dptr == NULL)
- return tdb->last_error;
- return TDB_SUCCESS;
-}
-
-enum TDB_ERROR tdb1_parse_record(struct tdb_context *tdb, TDB_DATA key,
- enum TDB_ERROR (*parser)(TDB_DATA key,
- TDB_DATA data,
- void *private_data),
- void *private_data)
-{
- tdb1_off_t rec_ptr;
- struct tdb1_record rec;
- enum TDB_ERROR ret;
- uint32_t hash;
-
- /* find which hash bucket it is in */
- hash = tdb_hash(tdb, key.dptr, key.dsize);
-
- if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
- return tdb->last_error;
- }
-
- ret = tdb1_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
- rec.data_len, parser, private_data);
-
- tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
-
- return ret;
-}
-
-/* check if an entry in the database exists
-
- note that 1 is returned if the key is found and 0 is returned if not found
- this doesn't match the conventions in the rest of this module, but is
- compatible with gdbm
-*/
-static int tdb1_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
-{
- struct tdb1_record rec;
-
- if (tdb1_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
- return 0;
- tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
- return 1;
-}
-
-int tdb1_exists(struct tdb_context *tdb, TDB_DATA key)
-{
- uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
- int ret;
-
- assert(tdb->flags & TDB_VERSION1);
- ret = tdb1_exists_hash(tdb, key, hash);
- return ret;
-}
-
-/* actually delete an entry in the database given the offset */
-int tdb1_do_delete(struct tdb_context *tdb, tdb1_off_t rec_ptr, struct tdb1_record *rec)
-{
- tdb1_off_t last_ptr, i;
- struct tdb1_record lastrec;
-
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) return -1;
-
- if (((tdb->tdb1.traverse_write != 0) && (!TDB1_DEAD(rec))) ||
- tdb1_write_lock_record(tdb, rec_ptr) == -1) {
- /* Someone traversing here: mark it as dead */
- rec->magic = TDB1_DEAD_MAGIC;
- return tdb1_rec_write(tdb, rec_ptr, rec);
- }
- if (tdb1_write_unlock_record(tdb, rec_ptr) != 0)
- return -1;
-
- /* find previous record in hash chain */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(rec->full_hash), &i) == -1)
- return -1;
- for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
- if (tdb1_rec_read(tdb, i, &lastrec) == -1)
- return -1;
-
- /* unlink it: next ptr is at start of record. */
- if (last_ptr == 0)
- last_ptr = TDB1_HASH_TOP(rec->full_hash);
- if (tdb1_ofs_write(tdb, last_ptr, &rec->next) == -1)
- return -1;
-
- /* recover the space */
- if (tdb1_free(tdb, rec_ptr, rec) == -1)
- return -1;
- return 0;
-}
-
-static int tdb1_count_dead(struct tdb_context *tdb, uint32_t hash)
-{
- int res = 0;
- tdb1_off_t rec_ptr;
- struct tdb1_record rec;
-
- /* read in the hash top */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
- return 0;
-
- while (rec_ptr) {
- if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1)
- return 0;
-
- if (rec.magic == TDB1_DEAD_MAGIC) {
- res += 1;
- }
- rec_ptr = rec.next;
- }
- return res;
-}
-
-/*
- * Purge all DEAD records from a hash chain
- */
-static int tdb1_purge_dead(struct tdb_context *tdb, uint32_t hash)
-{
- int res = -1;
- struct tdb1_record rec;
- tdb1_off_t rec_ptr;
-
- if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
- return -1;
- }
-
- /* read in the hash top */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
- goto fail;
-
- while (rec_ptr) {
- tdb1_off_t next;
-
- if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1) {
- goto fail;
- }
-
- next = rec.next;
-
- if (rec.magic == TDB1_DEAD_MAGIC
- && tdb1_do_delete(tdb, rec_ptr, &rec) == -1) {
- goto fail;
- }
- rec_ptr = next;
- }
- res = 0;
- fail:
- tdb1_unlock(tdb, -1, F_WRLCK);
- return res;
-}
-
-/* delete an entry in the database given a key */
-static int tdb1_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
-{
- tdb1_off_t rec_ptr;
- struct tdb1_record rec;
- int ret;
-
- if (tdb->tdb1.max_dead_records != 0) {
-
- /*
- * Allow for some dead records per hash chain, mainly for
- * tdb's with a very high create/delete rate like locking.tdb.
- */
-
- if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
- return -1;
-
- if (tdb1_count_dead(tdb, hash) >= tdb->tdb1.max_dead_records) {
- /*
- * Don't let the per-chain freelist grow too large,
- * delete all existing dead records
- */
- tdb1_purge_dead(tdb, hash);
- }
-
- if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec))) {
- tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
- return -1;
- }
-
- /*
- * Just mark the record as dead.
- */
- rec.magic = TDB1_DEAD_MAGIC;
- ret = tdb1_rec_write(tdb, rec_ptr, &rec);
- }
- else {
- if (!(rec_ptr = tdb1_find_lock_hash(tdb, key, hash, F_WRLCK,
- &rec)))
- return -1;
-
- ret = tdb1_do_delete(tdb, rec_ptr, &rec);
- }
-
- if (ret == 0) {
- tdb1_increment_seqnum(tdb);
- }
-
- if (tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_WRLCK) != 0)
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_delete: WARNING tdb1_unlock failed!");
- return ret;
-}
-
-int tdb1_delete(struct tdb_context *tdb, TDB_DATA key)
-{
- uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
- int ret;
-
- assert(tdb->flags & TDB_VERSION1);
- ret = tdb1_delete_hash(tdb, key, hash);
- return ret;
-}
-
-/*
- * See if we have a dead record around with enough space
- */
-static tdb1_off_t tdb1_find_dead(struct tdb_context *tdb, uint32_t hash,
- struct tdb1_record *r, tdb1_len_t length)
-{
- tdb1_off_t rec_ptr;
-
- /* read in the hash top */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
- return 0;
-
- /* keep looking until we find the right record */
- while (rec_ptr) {
- if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
- return 0;
-
- if (TDB1_DEAD(r) && r->rec_len >= length) {
- /*
- * First fit for simple coding, TODO: change to best
- * fit
- */
- return rec_ptr;
- }
- rec_ptr = r->next;
- }
- return 0;
-}
-
-static int _tdb1_store(struct tdb_context *tdb, TDB_DATA key,
- TDB_DATA dbuf, int flag, uint32_t hash)
-{
- struct tdb1_record rec;
- tdb1_off_t rec_ptr;
- int ret = -1;
-
- /* check for it existing, on insert. */
- if (flag == TDB_INSERT) {
- if (tdb1_exists_hash(tdb, key, hash)) {
- tdb->last_error = TDB_ERR_EXISTS;
- goto fail;
- }
- if (tdb->last_error != TDB_ERR_NOEXIST) {
- goto fail;
- }
- } else {
- /* first try in-place update, on modify or replace. */
- if (tdb1_update_hash(tdb, key, hash, dbuf) == 0) {
- goto done;
- }
- if (tdb->last_error != TDB_SUCCESS) {
- if (tdb->last_error != TDB_ERR_NOEXIST) {
- goto fail;
- }
- if (flag == TDB_MODIFY) {
- /* if the record doesn't exist and we are in TDB1_MODIFY mode then
- we should fail the store */
- goto fail;
- }
- }
- }
- /* reset the error code potentially set by the tdb1_update() */
- 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
- coalescing with `allocated' block before it's updated. */
- if (flag != TDB_INSERT)
- tdb1_delete_hash(tdb, key, hash);
-
- if (tdb->tdb1.max_dead_records != 0) {
- /*
- * Allow for some dead records per hash chain, look if we can
- * find one that can hold the new record. We need enough space
- * for key, data and tailer. If we find one, we don't have to
- * consult the central freelist.
- */
- rec_ptr = tdb1_find_dead(
- tdb, hash, &rec,
- key.dsize + dbuf.dsize + sizeof(tdb1_off_t));
-
- if (rec_ptr != 0) {
- rec.key_len = key.dsize;
- rec.data_len = dbuf.dsize;
- rec.full_hash = hash;
- rec.magic = TDB1_MAGIC;
- if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
- || tdb->tdb1.io->tdb1_write(
- tdb, rec_ptr + sizeof(rec),
- key.dptr, key.dsize) == -1
- || tdb->tdb1.io->tdb1_write(
- tdb, rec_ptr + sizeof(rec) + key.dsize,
- dbuf.dptr, dbuf.dsize) == -1) {
- goto fail;
- }
- goto done;
- }
- }
-
- /*
- * We have to allocate some space from the freelist, so this means we
- * have to lock it. Use the chance to purge all the DEAD records from
- * the hash chain under the freelist lock.
- */
-
- if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
- goto fail;
- }
-
- if ((tdb->tdb1.max_dead_records != 0)
- && (tdb1_purge_dead(tdb, hash) == -1)) {
- tdb1_unlock(tdb, -1, F_WRLCK);
- goto fail;
- }
-
- /* we have to allocate some space */
- rec_ptr = tdb1_allocate(tdb, key.dsize + dbuf.dsize, &rec);
-
- tdb1_unlock(tdb, -1, F_WRLCK);
-
- if (rec_ptr == 0) {
- goto fail;
- }
-
- /* Read hash top into next ptr */
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec.next) == -1)
- goto fail;
-
- rec.key_len = key.dsize;
- rec.data_len = dbuf.dsize;
- rec.full_hash = hash;
- rec.magic = TDB1_MAGIC;
-
- /* write out and point the top of the hash chain at it */
- if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
- || tdb->tdb1.io->tdb1_write(tdb, rec_ptr + sizeof(rec),
- key.dptr, key.dsize) == -1
- || tdb->tdb1.io->tdb1_write(tdb, rec_ptr + sizeof(rec) + key.dsize,
- dbuf.dptr, dbuf.dsize) == -1
- || tdb1_ofs_write(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1) {
- /* Need to tdb1_unallocate() here */
- goto fail;
- }
-
- done:
- ret = 0;
- fail:
- if (ret == 0) {
- tdb1_increment_seqnum(tdb);
- }
- return ret;
-}
-
-/* store an element in the database, replacing any existing element
- with the same key
-
- return 0 on success, -1 on failure
-*/
-int tdb1_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
-{
- uint32_t hash;
- int ret;
-
- assert(tdb->flags & TDB_VERSION1);
-
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_RDONLY,
- TDB_LOG_USE_ERROR,
- "tdb_store: read-only tdb");
- return -1;
- }
-
- /* find which hash bucket it is in */
- hash = tdb_hash(tdb, key.dptr, key.dsize);
- if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
- return -1;
-
- ret = _tdb1_store(tdb, key, dbuf, flag, hash);
- tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
- return ret;
-}
-
-/* Append to an entry. Create if not exist. */
-int tdb1_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
-{
- uint32_t hash;
- TDB_DATA dbuf;
- int ret = -1;
-
- assert(tdb->flags & TDB_VERSION1);
-
- /* find which hash bucket it is in */
- hash = tdb_hash(tdb, key.dptr, key.dsize);
- if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
- return -1;
-
- dbuf = _tdb1_fetch(tdb, key);
-
- if (dbuf.dptr == NULL) {
- dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
- } else {
- unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
- unsigned char *new_dptr;
-
- /* realloc '0' is special: don't do that. */
- if (new_len == 0)
- new_len = 1;
- new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
- if (new_dptr == NULL) {
- free(dbuf.dptr);
- }
- dbuf.dptr = new_dptr;
- }
-
- if (dbuf.dptr == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- goto failed;
- }
-
- memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
- dbuf.dsize += new_dbuf.dsize;
-
- ret = _tdb1_store(tdb, key, dbuf, 0, hash);
-
-failed:
- tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
- SAFE_FREE(dbuf.dptr);
- return ret;
-}
-
-
-/*
- 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'
- test, not for code that relies on the count of the number of changes
- made. If you want a counter then use a tdb record.
-
- The aim of this sequence number is to allow for a very lightweight
- test of a possible tdb change.
-*/
-int tdb1_get_seqnum(struct tdb_context *tdb)
-{
- tdb1_off_t seqnum=0;
-
- tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
- return seqnum;
-}
-
-
-/*
- add a region of the file to the freelist. Length is the size of the region in bytes,
- which includes the free list header that needs to be added
- */
-static int tdb1_free_region(struct tdb_context *tdb, tdb1_off_t offset, ssize_t length)
-{
- struct tdb1_record rec;
- if (length <= sizeof(rec)) {
- /* the region is not worth adding */
- return 0;
- }
- if (length + offset > tdb->file->map_size) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_free_region: failed to add free record");
- return -1;
- }
- return 0;
-}
-
-/*
- wipe the entire database, deleting all records. This can be done
- very fast by using a allrecord lock. The entire data portion of the
- file becomes a single entry in the freelist.
-
- This code carefully steps around the recovery area, leaving it alone
- */
-int tdb1_wipe_all(struct tdb_context *tdb)
-{
- int i;
- tdb1_off_t offset = 0;
- ssize_t data_len;
- tdb1_off_t recovery_head;
- tdb1_len_t recovery_size = 0;
-
- if (tdb_lockall(tdb) != TDB_SUCCESS) {
- return -1;
- }
-
-
- /* see if the tdb has a recovery area, and remember its size
- if so. We don't want to lose this as otherwise each
- 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) {
- 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->tdb1.io->tdb1_read(tdb, recovery_head, &rec, sizeof(rec), TDB1_DOCONV()) == -1) {
- 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);
- }
-
- /* wipe the hashes */
- for (i=0;i<tdb->tdb1.header.hash_size;i++) {
- if (tdb1_ofs_write(tdb, TDB1_HASH_TOP(i), &offset) == -1) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_wipe_all: failed to write freelist");
- goto failed;
- }
-
- /* add all the rest of the file to the freelist, possibly leaving a gap
- for the recovery area */
- if (recovery_size == 0) {
- /* the simple case - the whole file can be used as a freelist */
- data_len = (tdb->file->map_size - TDB1_DATA_START(tdb->tdb1.header.hash_size));
- if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
- goto failed;
- }
- } else {
- /* we need to add two freelist entries - one on either
- side of the recovery area
-
- Note that we cannot shift the recovery area during
- this operation. Only the transaction.c code may
- move the recovery area or we risk subtle data
- corruption
- */
- data_len = (recovery_head - TDB1_DATA_START(tdb->tdb1.header.hash_size));
- if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
- goto failed;
- }
- /* and the 2nd free list entry after the recovery area - if any */
- data_len = tdb->file->map_size - (recovery_head+recovery_size);
- if (tdb1_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
- goto failed;
- }
- }
-
- tdb1_increment_seqnum_nonblock(tdb);
- tdb_unlockall(tdb);
- return 0;
-
-failed:
- tdb_unlockall(tdb);
- return -1;
-}
-
-/* Even on files, we can get partial writes due to signals. */
-bool tdb1_write_all(int fd, const void *buf, size_t count)
-{
- while (count) {
- ssize_t ret;
- ret = write(fd, buf, count);
- if (ret < 0)
- return false;
- buf = (const char *)buf + ret;
- count -= ret;
- }
- return true;
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 2005
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "tdb1_private.h"
-
-/*
- transaction design:
-
- - only allow a single transaction at a time per database. This makes
- using the transaction API simpler, as otherwise the caller would
- have to cope with temporary failures in transactions that conflict
- with other current transactions
-
- - keep the transaction recovery information in the same file as the
- database, using a special 'transaction recovery' record pointed at
- by the header. This removes the need for extra journal files as
- used by some other databases
-
- - dynamically allocated the transaction recover record, re-using it
- for subsequent transactions. If a larger record is needed then
- tdb1_free() the old record to place it on the normal tdb freelist
- before allocating the new record
-
- - during transactions, keep a linked list of writes all that have
- been performed by intercepting all tdb1_write() calls. The hooked
- transaction versions of tdb1_read() and tdb1_write() check this
- linked list and try to use the elements of the list in preference
- to the real database.
-
- - don't allow any locks to be held when a transaction starts,
- otherwise we can end up with deadlock (plus lack of lock nesting
- in posix locks would mean the lock is lost)
-
- - if the caller gains a lock during the transaction but doesn't
- release it then fail the commit
-
- - allow for nested calls to tdb1_transaction_start(), re-using the
- existing transaction record. If the inner transaction is cancelled
- then a subsequent commit will fail
-
- - keep a mirrored copy of the tdb hash chain heads to allow for the
- fast hash heads scan on traverse, updating the mirrored copy in
- the transaction version of tdb1_write
-
- - allow callers to mix transaction and non-transaction use of tdb,
- although once a transaction is started then an exclusive lock is
- gained until the transaction is committed or cancelled
-
- - the commit stategy involves first saving away all modified data
- into a linearised buffer in the transaction recovery area, then
- marking the transaction recovery area with a magic value to
- indicate a valid recovery record. In total 4 fsync/msync calls are
- needed per commit to prevent race conditions. It might be possible
- to reduce this to 3 or even 2 with some more work.
-
- - check for a valid recovery record on open of the tdb, while the
- open lock is held. Automatically recover from the transaction
- recovery area if needed, then continue with the open as
- usual. This allows for smooth crash recovery with no administrator
- intervention.
-
- - if TDB_NOSYNC is passed to flags in tdb1_open then transactions are
- still available, but no transaction recovery area is used and no
- fsync/msync calls are made.
-
- - if TDB_ALLOW_NESTING is passed to flags in tdb open, or added using
- tdb1_add_flags() transaction nesting is enabled.
- The default is that transaction nesting is NOT allowed.
-
- Beware. when transactions are nested a transaction successfully
- completed with tdb1_transaction_commit() can be silently unrolled later.
-*/
-
-
-/*
- hold the context of any current transaction
-*/
-struct tdb1_transaction {
- /* we keep a mirrored copy of the tdb hash heads here so
- tdb1_next_hash_chain() can operate efficiently */
- uint32_t *hash_heads;
-
- /* the original io methods - used to do IOs to the real db */
- const struct tdb1_methods *io_methods;
-
- /* the list of transaction blocks. When a block is first
- written to, it gets created in this list */
- uint8_t **blocks;
- uint32_t num_blocks;
- uint32_t block_size; /* bytes in each block */
- uint32_t last_block_size; /* number of valid bytes in the last block */
-
- /* non-zero when an internal transaction error has
- occurred. All write operations will then fail until the
- transaction is ended */
- int transaction_error;
-
- /* when inside a transaction we need to keep track of any
- nested tdb1_transaction_start() calls, as these are allowed,
- but don't create a new transaction */
- int nesting;
-
- /* set when a prepare has already occurred */
- bool prepared;
- tdb1_off_t magic_offset;
-
- /* old file size before transaction */
- tdb1_len_t old_map_size;
-
- /* did we expand in this transaction */
- bool expanded;
-};
-
-
-/*
- read while in a transaction. We need to check first if the data is in our list
- of transaction elements, then if not do a real read
-*/
-static int transaction1_read(struct tdb_context *tdb, tdb1_off_t off, void *buf,
- tdb1_len_t len, int cv)
-{
- uint32_t blk;
-
- /* break it down into block sized ops */
- while (len + (off % tdb->tdb1.transaction->block_size) > tdb->tdb1.transaction->block_size) {
- tdb1_len_t len2 = tdb->tdb1.transaction->block_size - (off % tdb->tdb1.transaction->block_size);
- if (transaction1_read(tdb, off, buf, len2, cv) != 0) {
- return -1;
- }
- len -= len2;
- off += len2;
- buf = (void *)(len2 + (char *)buf);
- }
-
- if (len == 0) {
- return 0;
- }
-
- blk = off / tdb->tdb1.transaction->block_size;
-
- /* see if we have it in the block list */
- if (tdb->tdb1.transaction->num_blocks <= blk ||
- tdb->tdb1.transaction->blocks[blk] == NULL) {
- /* nope, do a real read */
- if (tdb->tdb1.transaction->io_methods->tdb1_read(tdb, off, buf, len, cv) != 0) {
- goto fail;
- }
- return 0;
- }
-
- /* it is in the block list. Now check for the last block */
- if (blk == tdb->tdb1.transaction->num_blocks-1) {
- if (len > tdb->tdb1.transaction->last_block_size) {
- goto fail;
- }
- }
-
- /* now copy it out of this block */
- memcpy(buf, tdb->tdb1.transaction->blocks[blk] + (off % tdb->tdb1.transaction->block_size), len);
- if (cv) {
- tdb1_convert(buf, len);
- }
- return 0;
-
-fail:
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "transaction_read: failed at off=%d len=%d",
- off, len);
- tdb->tdb1.transaction->transaction_error = 1;
- return -1;
-}
-
-
-/*
- write while in a transaction
-*/
-static int transaction1_write(struct tdb_context *tdb, tdb1_off_t off,
- const void *buf, tdb1_len_t len)
-{
- uint32_t blk;
-
- /* Only a commit is allowed on a prepared transaction */
- if (tdb->tdb1.transaction->prepared) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "transaction_write: transaction already"
- " prepared, write not allowed");
- tdb->tdb1.transaction->transaction_error = 1;
- return -1;
- }
-
- /* if the write is to a hash head, then update the transaction
- hash heads */
- if (len == sizeof(tdb1_off_t) && off >= TDB1_FREELIST_TOP &&
- off < TDB1_FREELIST_TOP+TDB1_HASHTABLE_SIZE(tdb)) {
- uint32_t chain = (off-TDB1_FREELIST_TOP) / sizeof(tdb1_off_t);
- memcpy(&tdb->tdb1.transaction->hash_heads[chain], buf, len);
- }
-
- /* break it up into block sized chunks */
- while (len + (off % tdb->tdb1.transaction->block_size) > tdb->tdb1.transaction->block_size) {
- tdb1_len_t len2 = tdb->tdb1.transaction->block_size - (off % tdb->tdb1.transaction->block_size);
- if (transaction1_write(tdb, off, buf, len2) != 0) {
- return -1;
- }
- len -= len2;
- off += len2;
- if (buf != NULL) {
- buf = (const void *)(len2 + (const char *)buf);
- }
- }
-
- if (len == 0) {
- return 0;
- }
-
- blk = off / tdb->tdb1.transaction->block_size;
- off = off % tdb->tdb1.transaction->block_size;
-
- if (tdb->tdb1.transaction->num_blocks <= blk) {
- uint8_t **new_blocks;
- /* expand the blocks array */
- if (tdb->tdb1.transaction->blocks == NULL) {
- new_blocks = (uint8_t **)malloc(
- (blk+1)*sizeof(uint8_t *));
- } else {
- new_blocks = (uint8_t **)realloc(
- tdb->tdb1.transaction->blocks,
- (blk+1)*sizeof(uint8_t *));
- }
- if (new_blocks == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- goto fail;
- }
- memset(&new_blocks[tdb->tdb1.transaction->num_blocks], 0,
- (1+(blk - tdb->tdb1.transaction->num_blocks))*sizeof(uint8_t *));
- tdb->tdb1.transaction->blocks = new_blocks;
- tdb->tdb1.transaction->num_blocks = blk+1;
- tdb->tdb1.transaction->last_block_size = 0;
- }
-
- /* allocate and fill a block? */
- if (tdb->tdb1.transaction->blocks[blk] == NULL) {
- tdb->tdb1.transaction->blocks[blk] = (uint8_t *)calloc(tdb->tdb1.transaction->block_size, 1);
- if (tdb->tdb1.transaction->blocks[blk] == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- tdb->tdb1.transaction->transaction_error = 1;
- return -1;
- }
- if (tdb->tdb1.transaction->old_map_size > blk * tdb->tdb1.transaction->block_size) {
- tdb1_len_t len2 = tdb->tdb1.transaction->block_size;
- if (len2 + (blk * tdb->tdb1.transaction->block_size) > tdb->tdb1.transaction->old_map_size) {
- len2 = tdb->tdb1.transaction->old_map_size - (blk * tdb->tdb1.transaction->block_size);
- }
- if (tdb->tdb1.transaction->io_methods->tdb1_read(tdb, blk * tdb->tdb1.transaction->block_size,
- tdb->tdb1.transaction->blocks[blk],
- len2, 0) != 0) {
- SAFE_FREE(tdb->tdb1.transaction->blocks[blk]);
- tdb->last_error = TDB_ERR_IO;
- goto fail;
- }
- if (blk == tdb->tdb1.transaction->num_blocks-1) {
- tdb->tdb1.transaction->last_block_size = len2;
- }
- }
- }
-
- /* overwrite part of an existing block */
- if (buf == NULL) {
- memset(tdb->tdb1.transaction->blocks[blk] + off, 0, len);
- } else {
- memcpy(tdb->tdb1.transaction->blocks[blk] + off, buf, len);
- }
- if (blk == tdb->tdb1.transaction->num_blocks-1) {
- if (len + off > tdb->tdb1.transaction->last_block_size) {
- tdb->tdb1.transaction->last_block_size = len + off;
- }
- }
-
- return 0;
-
-fail:
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "transaction_write: failed at off=%d len=%d",
- (blk*tdb->tdb1.transaction->block_size) + off, len);
- tdb->tdb1.transaction->transaction_error = 1;
- return -1;
-}
-
-
-/*
- write while in a transaction - this varient never expands the transaction blocks, it only
- updates existing blocks. This means it cannot change the recovery size
-*/
-static int transaction1_write_existing(struct tdb_context *tdb, tdb1_off_t off,
- const void *buf, tdb1_len_t len)
-{
- uint32_t blk;
-
- /* break it up into block sized chunks */
- while (len + (off % tdb->tdb1.transaction->block_size) > tdb->tdb1.transaction->block_size) {
- tdb1_len_t len2 = tdb->tdb1.transaction->block_size - (off % tdb->tdb1.transaction->block_size);
- if (transaction1_write_existing(tdb, off, buf, len2) != 0) {
- return -1;
- }
- len -= len2;
- off += len2;
- if (buf != NULL) {
- buf = (const void *)(len2 + (const char *)buf);
- }
- }
-
- if (len == 0) {
- return 0;
- }
-
- blk = off / tdb->tdb1.transaction->block_size;
- off = off % tdb->tdb1.transaction->block_size;
-
- if (tdb->tdb1.transaction->num_blocks <= blk ||
- tdb->tdb1.transaction->blocks[blk] == NULL) {
- return 0;
- }
-
- if (blk == tdb->tdb1.transaction->num_blocks-1 &&
- off + len > tdb->tdb1.transaction->last_block_size) {
- if (off >= tdb->tdb1.transaction->last_block_size) {
- return 0;
- }
- len = tdb->tdb1.transaction->last_block_size - off;
- }
-
- /* overwrite part of an existing block */
- memcpy(tdb->tdb1.transaction->blocks[blk] + off, buf, len);
-
- return 0;
-}
-
-
-/*
- accelerated hash chain head search, using the cached hash heads
-*/
-static void transaction1_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
-{
- uint32_t h = *chain;
- for (;h < tdb->tdb1.header.hash_size;h++) {
- /* the +1 takes account of the freelist */
- if (0 != tdb->tdb1.transaction->hash_heads[h+1]) {
- break;
- }
- }
- (*chain) = h;
-}
-
-/*
- out of bounds check during a transaction
-*/
-static int transaction1_oob(struct tdb_context *tdb, tdb1_off_t len, int probe)
-{
- if (len <= tdb->file->map_size) {
- return 0;
- }
- tdb->last_error = TDB_ERR_IO;
- return -1;
-}
-
-/*
- transaction version of tdb1_expand().
-*/
-static int transaction1_expand_file(struct tdb_context *tdb, tdb1_off_t size,
- tdb1_off_t addition)
-{
- /* add a write to the transaction elements, so subsequent
- reads see the zero data */
- if (transaction1_write(tdb, size, NULL, addition) != 0) {
- return -1;
- }
-
- tdb->tdb1.transaction->expanded = true;
-
- return 0;
-}
-
-static const struct tdb1_methods transaction1_methods = {
- transaction1_read,
- transaction1_write,
- transaction1_next_hash_chain,
- transaction1_oob,
- transaction1_expand_file,
-};
-
-
-/*
- start a tdb transaction. No token is returned, as only a single
- transaction is allowed to be pending per tdb_context
-*/
-static int _tdb1_transaction_start(struct tdb_context *tdb)
-{
- /* some sanity checks */
- if (tdb->flags & TDB_INTERNAL) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb1_transaction_start:"
- " cannot start a"
- " transaction on an"
- " internal tdb");
- return -1;
- }
-
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_RDONLY,
- TDB_LOG_USE_ERROR,
- "tdb_transaction_start:"
- " cannot start a"
- " transaction on a "
- " read-only tdb");
- return -1;
- }
-
- /* cope with nested tdb1_transaction_start() calls */
- if (tdb->tdb1.transaction != NULL) {
- if (!(tdb->flags & TDB_ALLOW_NESTING)) {
- tdb->last_error
- = tdb_logerr(tdb, TDB_ERR_EINVAL,
- TDB_LOG_USE_ERROR,
- "tdb_transaction_start:"
- " already inside transaction");
- return -1;
- }
- tdb->stats.transaction_nest++;
- tdb->tdb1.transaction->nesting++;
- return 0;
- }
-
- if (tdb1_have_extra_locks(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 */
- 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;
- }
-
- if (tdb->tdb1.travlocks.next != NULL) {
- /* you cannot use transactions inside a traverse (although you can use
- traverse inside a transaction) as otherwise you can end up with
- deadlock */
- 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->tdb1.transaction = (struct tdb1_transaction *)
- calloc(sizeof(struct tdb1_transaction), 1);
- if (tdb->tdb1.transaction == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- return -1;
- }
-
- /* a page at a time seems like a reasonable compromise between compactness and efficiency */
- tdb->tdb1.transaction->block_size = tdb->tdb1.page_size;
-
- /* get the transaction write lock. This is a blocking lock. As
- discussed with Volker, there are a number of ways we could
- make this async, which we will probably do in the future */
- if (tdb1_transaction_lock(tdb, F_WRLCK, TDB_LOCK_WAIT) == -1) {
- SAFE_FREE(tdb->tdb1.transaction->blocks);
- SAFE_FREE(tdb->tdb1.transaction);
- return -1;
- }
-
- /* 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, TDB_LOCK_WAIT, true) == -1) {
- if (errno != EAGAIN && errno != EINTR) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_start:"
- " failed to get hash locks");
- }
- goto fail_allrecord_lock;
- }
-
- /* setup a copy of the hash table heads so the hash scan in
- traverse can be fast */
- tdb->tdb1.transaction->hash_heads = (uint32_t *)
- calloc(tdb->tdb1.header.hash_size+1, sizeof(uint32_t));
- if (tdb->tdb1.transaction->hash_heads == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- goto fail;
- }
- if (tdb->tdb1.io->tdb1_read(tdb, TDB1_FREELIST_TOP, tdb->tdb1.transaction->hash_heads,
- TDB1_HASHTABLE_SIZE(tdb), 0) != 0) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_start: failed to read hash heads");
- goto fail;
- }
-
- /* make sure we know about any file expansions already done by
- anyone else */
- tdb->tdb1.io->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
- tdb->tdb1.transaction->old_map_size = tdb->file->map_size;
-
- /* finally hook the io methods, replacing them with
- transaction specific methods */
- tdb->tdb1.transaction->io_methods = tdb->tdb1.io;
- tdb->tdb1.io = &transaction1_methods;
-
- tdb->stats.transactions++;
- return 0;
-
-fail:
- tdb1_allrecord_unlock(tdb, F_RDLCK);
-fail_allrecord_lock:
- tdb1_transaction_unlock(tdb, F_WRLCK);
- SAFE_FREE(tdb->tdb1.transaction->blocks);
- SAFE_FREE(tdb->tdb1.transaction->hash_heads);
- SAFE_FREE(tdb->tdb1.transaction);
- return -1;
-}
-
-int tdb1_transaction_start(struct tdb_context *tdb)
-{
- return _tdb1_transaction_start(tdb);
-}
-
-/*
- sync to disk
-*/
-static int transaction1_sync(struct tdb_context *tdb, tdb1_off_t offset, tdb1_len_t length)
-{
- if (tdb->flags & TDB_NOSYNC) {
- return 0;
- }
-
-#if HAVE_FDATASYNC
- if (fdatasync(tdb->file->fd) != 0) {
-#else
- if (fsync(tdb->file->fd) != 0) {
-#endif
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_transaction: fsync failed");
- return -1;
- }
-#if HAVE_MMAP
- if (tdb->file->map_ptr) {
- tdb1_off_t moffset = offset & ~(tdb->tdb1.page_size-1);
- if (msync(moffset + (char *)tdb->file->map_ptr,
- length + (offset - moffset), MS_SYNC) != 0) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_transaction:"
- " msync failed - %s",
- strerror(errno));
- return -1;
- }
- }
-#endif
- return 0;
-}
-
-
-static int _tdb1_transaction_cancel(struct tdb_context *tdb)
-{
- int i, ret = 0;
-
- if (tdb->tdb1.transaction == NULL) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "tdb1_transaction_cancel:"
- " no transaction");
- return -1;
- }
-
- if (tdb->tdb1.transaction->nesting != 0) {
- tdb->tdb1.transaction->transaction_error = 1;
- tdb->tdb1.transaction->nesting--;
- return 0;
- }
-
- tdb->file->map_size = tdb->tdb1.transaction->old_map_size;
-
- /* free all the transaction blocks */
- for (i=0;i<tdb->tdb1.transaction->num_blocks;i++) {
- if (tdb->tdb1.transaction->blocks[i] != NULL) {
- free(tdb->tdb1.transaction->blocks[i]);
- }
- }
- SAFE_FREE(tdb->tdb1.transaction->blocks);
-
- if (tdb->tdb1.transaction->magic_offset) {
- const struct tdb1_methods *methods = tdb->tdb1.transaction->io_methods;
- const uint32_t invalid = TDB1_RECOVERY_INVALID_MAGIC;
-
- /* remove the recovery marker */
- if (methods->tdb1_write(tdb, tdb->tdb1.transaction->magic_offset, &invalid, 4) == -1 ||
- transaction1_sync(tdb, tdb->tdb1.transaction->magic_offset, 4) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_cancel: failed to"
- " remove recovery magic");
- ret = -1;
- }
- }
-
- /* This also removes the OPEN_LOCK, if we have it. */
- tdb1_release_transaction_locks(tdb);
-
- /* restore the normal io methods */
- tdb->tdb1.io = tdb->tdb1.transaction->io_methods;
-
- SAFE_FREE(tdb->tdb1.transaction->hash_heads);
- SAFE_FREE(tdb->tdb1.transaction);
-
- return ret;
-}
-
-/*
- cancel the current transaction
-*/
-int tdb1_transaction_cancel(struct tdb_context *tdb)
-{
- tdb->stats.transaction_cancel++;
- return _tdb1_transaction_cancel(tdb);
-}
-
-/*
- work out how much space the linearised recovery data will consume
-*/
-static tdb1_len_t tdb1_recovery_size(struct tdb_context *tdb)
-{
- tdb1_len_t recovery_size = 0;
- int i;
-
- recovery_size = sizeof(uint32_t);
- for (i=0;i<tdb->tdb1.transaction->num_blocks;i++) {
- if (i * tdb->tdb1.transaction->block_size >= tdb->tdb1.transaction->old_map_size) {
- break;
- }
- if (tdb->tdb1.transaction->blocks[i] == NULL) {
- continue;
- }
- recovery_size += 2*sizeof(tdb1_off_t);
- if (i == tdb->tdb1.transaction->num_blocks-1) {
- recovery_size += tdb->tdb1.transaction->last_block_size;
- } else {
- recovery_size += tdb->tdb1.transaction->block_size;
- }
- }
-
- return recovery_size;
-}
-
-int tdb1_recovery_area(struct tdb_context *tdb,
- const struct tdb1_methods *methods,
- tdb1_off_t *recovery_offset,
- struct tdb1_record *rec)
-{
- if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, recovery_offset) == -1) {
- return -1;
- }
-
- if (*recovery_offset == 0) {
- rec->rec_len = 0;
- return 0;
- }
-
- if (methods->tdb1_read(tdb, *recovery_offset, rec, sizeof(*rec),
- TDB1_DOCONV()) == -1) {
- return -1;
- }
-
- /* ignore invalid recovery regions: can happen in crash */
- if (rec->magic != TDB1_RECOVERY_MAGIC &&
- rec->magic != TDB1_RECOVERY_INVALID_MAGIC) {
- *recovery_offset = 0;
- rec->rec_len = 0;
- }
- return 0;
-}
-
-/*
- allocate the recovery area, or use an existing recovery area if it is
- large enough
-*/
-static int tdb1_recovery_allocate(struct tdb_context *tdb,
- tdb1_len_t *recovery_size,
- tdb1_off_t *recovery_offset,
- tdb1_len_t *recovery_max_size)
-{
- struct tdb1_record rec;
- const struct tdb1_methods *methods = tdb->tdb1.transaction->io_methods;
- tdb1_off_t recovery_head;
-
- if (tdb1_recovery_area(tdb, methods, &recovery_head, &rec) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_recovery_allocate:"
- " failed to read recovery head");
- return -1;
- }
-
- *recovery_size = tdb1_recovery_size(tdb);
-
- if (recovery_head != 0 && *recovery_size <= rec.rec_len) {
- /* it fits in the existing area */
- *recovery_max_size = rec.rec_len;
- *recovery_offset = recovery_head;
- return 0;
- }
-
- /* we need to free up the old recovery area, then allocate a
- new one at the end of the file. Note that we cannot use
- tdb1_allocate() to allocate the new one as that might return
- us an area that is being currently used (as of the start of
- the transaction) */
- if (recovery_head != 0) {
- if (tdb1_free(tdb, recovery_head, &rec) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_recovery_allocate: failed to free"
- " previous recovery area");
- return -1;
- }
- }
-
- /* the tdb1_free() call might have increased the recovery size */
- *recovery_size = tdb1_recovery_size(tdb);
-
- /* round up to a multiple of page size */
- *recovery_max_size = TDB1_ALIGN(sizeof(rec) + *recovery_size,
- tdb->tdb1.page_size) - sizeof(rec);
- *recovery_offset = tdb->file->map_size;
- recovery_head = *recovery_offset;
-
- if (methods->tdb1_expand_file(tdb, tdb->tdb1.transaction->old_map_size,
- (tdb->file->map_size - tdb->tdb1.transaction->old_map_size) +
- sizeof(rec) + *recovery_max_size) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_recovery_allocate:"
- " failed to create recovery area");
- return -1;
- }
- tdb->stats.transaction_expand_file++;
-
- /* remap the file (if using mmap) */
- methods->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
-
- /* we have to reset the old map size so that we don't try to expand the file
- again in the transaction commit, which would destroy the recovery area */
- tdb->tdb1.transaction->old_map_size = tdb->file->map_size;
-
- /* write the recovery header offset and sync - we can sync without a race here
- as the magic ptr in the recovery record has not been set */
- TDB1_CONV(recovery_head);
- if (methods->tdb1_write(tdb, TDB1_RECOVERY_HEAD,
- &recovery_head, sizeof(tdb1_off_t)) == -1) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_recovery_allocate:"
- " failed to write recovery head");
- return -1;
- }
-
- return 0;
-}
-
-
-/*
- setup the recovery data that will be used on a crash during commit
-*/
-static int transaction1_setup_recovery(struct tdb_context *tdb,
- tdb1_off_t *magic_offset)
-{
- tdb1_len_t recovery_size;
- unsigned char *data, *p;
- const struct tdb1_methods *methods = tdb->tdb1.transaction->io_methods;
- struct tdb1_record *rec;
- tdb1_off_t recovery_offset, recovery_max_size;
- tdb1_off_t old_map_size = tdb->tdb1.transaction->old_map_size;
- uint32_t magic, tailer;
- int i;
-
- /*
- check that the recovery area has enough space
- */
- if (tdb1_recovery_allocate(tdb, &recovery_size,
- &recovery_offset, &recovery_max_size) == -1) {
- return -1;
- }
-
- data = (unsigned char *)malloc(recovery_size + sizeof(*rec));
- if (data == NULL) {
- tdb->last_error = TDB_ERR_OOM;
- return -1;
- }
-
- rec = (struct tdb1_record *)data;
- memset(rec, 0, sizeof(*rec));
-
- rec->magic = TDB1_RECOVERY_INVALID_MAGIC;
- rec->data_len = recovery_size;
- rec->rec_len = recovery_max_size;
- rec->key_len = old_map_size;
- TDB1_CONV(*rec);
-
- /* build the recovery data into a single blob to allow us to do a single
- large write, which should be more efficient */
- p = data + sizeof(*rec);
- for (i=0;i<tdb->tdb1.transaction->num_blocks;i++) {
- tdb1_off_t offset;
- tdb1_len_t length;
-
- if (tdb->tdb1.transaction->blocks[i] == NULL) {
- continue;
- }
-
- offset = i * tdb->tdb1.transaction->block_size;
- length = tdb->tdb1.transaction->block_size;
- if (i == tdb->tdb1.transaction->num_blocks-1) {
- length = tdb->tdb1.transaction->last_block_size;
- }
-
- if (offset >= old_map_size) {
- continue;
- }
- if (offset + length > tdb->tdb1.transaction->old_map_size) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
- TDB_LOG_ERROR,
- "tdb1_transaction_setup_recovery: transaction data over new region boundary");
- free(data);
- return -1;
- }
- memcpy(p, &offset, 4);
- memcpy(p+4, &length, 4);
- if (TDB1_DOCONV()) {
- tdb1_convert(p, 8);
- }
- /* the recovery area contains the old data, not the
- new data, so we have to call the original tdb1_read
- method to get it */
- if (methods->tdb1_read(tdb, offset, p + 8, length, 0) != 0) {
- free(data);
- tdb->last_error = TDB_ERR_IO;
- return -1;
- }
- p += 8 + length;
- }
-
- /* and the tailer */
- tailer = sizeof(*rec) + recovery_max_size;
- memcpy(p, &tailer, 4);
- if (TDB1_DOCONV()) {
- tdb1_convert(p, 4);
- }
-
- /* write the recovery data to the recovery area */
- if (methods->tdb1_write(tdb, recovery_offset, data, sizeof(*rec) + recovery_size) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_setup_recovery:"
- " failed to write recovery data");
- free(data);
- return -1;
- }
- if (transaction1_write_existing(tdb, recovery_offset, data, sizeof(*rec) + recovery_size) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_setup_recovery: failed to write"
- " secondary recovery data");
- free(data);
- return -1;
- }
-
- /* as we don't have ordered writes, we have to sync the recovery
- data before we update the magic to indicate that the recovery
- data is present */
- if (transaction1_sync(tdb, recovery_offset, sizeof(*rec) + recovery_size) == -1) {
- free(data);
- return -1;
- }
-
- free(data);
-
- magic = TDB1_RECOVERY_MAGIC;
- TDB1_CONV(magic);
-
- *magic_offset = recovery_offset + offsetof(struct tdb1_record, magic);
-
- if (methods->tdb1_write(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_setup_recovery:"
- " failed to write secondary recovery magic");
- return -1;
- }
-
- /* ensure the recovery magic marker is on disk */
- if (transaction1_sync(tdb, *magic_offset, sizeof(magic)) == -1) {
- return -1;
- }
-
- return 0;
-}
-
-static int _tdb1_transaction_prepare_commit(struct tdb_context *tdb)
-{
- const struct tdb1_methods *methods;
-
- if (tdb->tdb1.transaction == NULL) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "tdb1_transaction_prepare_commit:"
- " no transaction");
- return -1;
- }
-
- if (tdb->tdb1.transaction->prepared) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "tdb1_transaction_prepare_commit:"
- " transaction already prepared");
- _tdb1_transaction_cancel(tdb);
- return -1;
- }
-
- if (tdb->tdb1.transaction->transaction_error) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_transaction_prepare_commit:"
- " transaction error pending");
- _tdb1_transaction_cancel(tdb);
- return -1;
- }
-
-
- if (tdb->tdb1.transaction->nesting != 0) {
- return 0;
- }
-
- /* check for a null transaction */
- if (tdb->tdb1.transaction->blocks == NULL) {
- return 0;
- }
-
- methods = tdb->tdb1.transaction->io_methods;
-
- /* 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->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) {
- if (errno != EAGAIN && errno != EINTR) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_prepare_commit:"
- " failed to upgrade hash locks");
- }
- return -1;
- }
-
- /* 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, TDB_LOCK_WAIT) == -1) {
- if (errno != EAGAIN && errno != EINTR) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_prepare_commit:"
- " failed to get open lock");
- }
- return -1;
- }
-
- if (!(tdb->flags & TDB_NOSYNC)) {
- /* write the recovery data to the end of the file */
- if (transaction1_setup_recovery(tdb, &tdb->tdb1.transaction->magic_offset) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_prepare_commit:"
- " failed to setup recovery data");
- return -1;
- }
- }
-
- tdb->tdb1.transaction->prepared = true;
-
- /* expand the file to the new size if needed */
- if (tdb->file->map_size != tdb->tdb1.transaction->old_map_size) {
- if (methods->tdb1_expand_file(tdb, tdb->tdb1.transaction->old_map_size,
- tdb->file->map_size -
- tdb->tdb1.transaction->old_map_size) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_prepare_commit:"
- " expansion failed");
- return -1;
- }
- tdb->stats.transaction_expand_file++;
- tdb->file->map_size = tdb->tdb1.transaction->old_map_size;
- methods->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
- }
-
- /* Keep the open lock until the actual commit */
-
- return 0;
-}
-
-/*
- prepare to commit the current transaction
-*/
-int tdb1_transaction_prepare_commit(struct tdb_context *tdb)
-{
- return _tdb1_transaction_prepare_commit(tdb);
-}
-
-/* A repack is worthwhile if the largest is less than half total free. */
-static bool repack_worthwhile(struct tdb_context *tdb)
-{
- tdb1_off_t ptr;
- struct tdb1_record rec;
- tdb1_len_t total = 0, largest = 0;
-
- if (tdb1_ofs_read(tdb, TDB1_FREELIST_TOP, &ptr) == -1) {
- return false;
- }
-
- while (ptr != 0 && tdb1_rec_free_read(tdb, ptr, &rec) == 0) {
- total += rec.rec_len;
- if (rec.rec_len > largest) {
- largest = rec.rec_len;
- }
- ptr = rec.next;
- }
-
- return total > largest * 2;
-}
-
-/*
- commit the current transaction
-*/
-int tdb1_transaction_commit(struct tdb_context *tdb)
-{
- const struct tdb1_methods *methods;
- int i;
- bool need_repack = false;
-
- if (tdb->tdb1.transaction == NULL) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL, TDB_LOG_USE_ERROR,
- "tdb1_transaction_commit:"
- " no transaction");
- return -1;
- }
-
- if (tdb->tdb1.transaction->transaction_error) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb1_transaction_commit:"
- " transaction error pending");
- _tdb1_transaction_cancel(tdb);
- return -1;
- }
-
-
- if (tdb->tdb1.transaction->nesting != 0) {
- tdb->tdb1.transaction->nesting--;
- return 0;
- }
-
- /* check for a null transaction */
- if (tdb->tdb1.transaction->blocks == NULL) {
- _tdb1_transaction_cancel(tdb);
- return 0;
- }
-
- if (!tdb->tdb1.transaction->prepared) {
- int ret = _tdb1_transaction_prepare_commit(tdb);
- if (ret) {
- _tdb1_transaction_cancel(tdb);
- return ret;
- }
- }
-
- methods = tdb->tdb1.transaction->io_methods;
-
- /* perform all the writes */
- for (i=0;i<tdb->tdb1.transaction->num_blocks;i++) {
- tdb1_off_t offset;
- tdb1_len_t length;
-
- if (tdb->tdb1.transaction->blocks[i] == NULL) {
- continue;
- }
-
- offset = i * tdb->tdb1.transaction->block_size;
- length = tdb->tdb1.transaction->block_size;
- if (i == tdb->tdb1.transaction->num_blocks-1) {
- length = tdb->tdb1.transaction->last_block_size;
- }
-
- if (methods->tdb1_write(tdb, offset, tdb->tdb1.transaction->blocks[i], length) == -1) {
- 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
- run the crash recovery code */
- tdb->tdb1.io = methods;
- tdb1_transaction_recover(tdb);
-
- _tdb1_transaction_cancel(tdb);
-
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_commit: write failed");
- return -1;
- }
- SAFE_FREE(tdb->tdb1.transaction->blocks[i]);
- }
-
- /* Do this before we drop lock or blocks. */
- if (tdb->tdb1.transaction->expanded) {
- need_repack = repack_worthwhile(tdb);
- }
-
- SAFE_FREE(tdb->tdb1.transaction->blocks);
- tdb->tdb1.transaction->num_blocks = 0;
-
- /* ensure the new data is on disk */
- if (transaction1_sync(tdb, 0, tdb->file->map_size) == -1) {
- return -1;
- }
-
- /*
- TODO: maybe write to some dummy hdr field, or write to magic
- offset without mmap, before the last sync, instead of the
- utime() call
- */
-
- /* on some systems (like Linux 2.6.x) changes via mmap/msync
- don't change the mtime of the file, this means the file may
- not be backed up (as tdb rounding to block sizes means that
- file size changes are quite rare too). The following forces
- mtime changes when a transaction completes */
-#if HAVE_UTIME
- utime(tdb->name, NULL);
-#endif
-
- /* use a transaction cancel to free memory and remove the
- transaction locks */
- _tdb1_transaction_cancel(tdb);
-
- if (need_repack) {
- if (tdb_repack(tdb) != 0)
- return -1;
- }
-
- return 0;
-}
-
-
-/*
- recover from an aborted transaction. Must be called with exclusive
- database write access already established (including the open
- lock to prevent new processes attaching)
-*/
-int tdb1_transaction_recover(struct tdb_context *tdb)
-{
- tdb1_off_t recovery_head, recovery_eof;
- unsigned char *data, *p;
- uint32_t zero = 0;
- struct tdb1_record rec;
-
- /* find the recovery area */
- if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_recover:"
- " failed to read recovery head");
- return -1;
- }
-
- if (recovery_head == 0) {
- /* we have never allocated a recovery record */
- return 0;
- }
-
- /* read the recovery record */
- if (tdb->tdb1.io->tdb1_read(tdb, recovery_head, &rec,
- sizeof(rec), TDB1_DOCONV()) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_recover:"
- " failed to read recovery record");
- return -1;
- }
-
- if (rec.magic != TDB1_RECOVERY_MAGIC) {
- /* there is no valid recovery data */
- return 0;
- }
-
- if (tdb->flags & TDB_RDONLY) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
- "tdb1_transaction_recover:"
- " attempt to recover read only"
- " database");
- return -1;
- }
-
- recovery_eof = rec.key_len;
-
- data = (unsigned char *)malloc(rec.data_len);
- if (data == NULL) {
- 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->tdb1.io->tdb1_read(tdb, recovery_head + sizeof(rec), data,
- rec.data_len, 0) == -1) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_recover:"
- " failed to read recovery data");
- return -1;
- }
-
- /* recover the file data */
- p = data;
- while (p+8 < data + rec.data_len) {
- uint32_t ofs, len;
- if (TDB1_DOCONV()) {
- tdb1_convert(p, 8);
- }
- memcpy(&ofs, p, 4);
- memcpy(&len, p+4, 4);
-
- if (tdb->tdb1.io->tdb1_write(tdb, ofs, p+8, len) == -1) {
- free(data);
- 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;
- }
-
- free(data);
-
- if (transaction1_sync(tdb, 0, tdb->file->map_size) == -1) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_recover: failed to remove"
- " recovery head");
- return -1;
- }
- }
-
- /* remove the recovery magic */
- if (tdb1_ofs_write(tdb, recovery_head + offsetof(struct tdb1_record, magic),
- &zero) == -1) {
- 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) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_transaction_recover:"
- " failed to sync2 recovery");
- return -1;
- }
-
- tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
- "tdb1_transaction_recover: recovered %d byte database",
- recovery_eof);
-
- /* all done */
- return 0;
-}
-
-/* Any I/O failures we say "needs recovery". */
-tdb_bool_err tdb1_needs_recovery(struct tdb_context *tdb)
-{
- tdb1_off_t recovery_head;
- struct tdb1_record rec;
-
- /* find the recovery area */
- if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
- return TDB_ERR_TO_OFF(tdb->last_error);
- }
-
- if (recovery_head == 0) {
- /* we have never allocated a recovery record */
- return false;
- }
-
- /* read the recovery record */
- if (tdb->tdb1.io->tdb1_read(tdb, recovery_head, &rec,
- sizeof(rec), TDB1_DOCONV()) == -1) {
- return TDB_ERR_TO_OFF(tdb->last_error);
- }
-
- return (rec.magic == TDB1_RECOVERY_MAGIC);
-}
+++ /dev/null
- /*
- Unix SMB/CIFS implementation.
-
- trivial database library
-
- Copyright (C) Andrew Tridgell 1999-2005
- Copyright (C) Paul `Rusty' Russell 2000
- Copyright (C) Jeremy Allison 2000-2003
-
- ** NOTE! The following LGPL license applies to the tdb
- ** library. This does NOT imply that all of Samba is released
- ** under the LGPL
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 3 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "tdb1_private.h"
-
-#define TDB1_NEXT_LOCK_ERR ((tdb1_off_t)-1)
-
-static TDB_DATA tdb1_null;
-
-/* Uses traverse lock: 0 = finish, TDB1_NEXT_LOCK_ERR = error,
- other = record offset */
-static tdb1_off_t tdb1_next_lock(struct tdb_context *tdb, struct tdb1_traverse_lock *tlock,
- struct tdb1_record *rec)
-{
- int want_next = (tlock->off != 0);
-
- /* Lock each chain from the start one. */
- for (; tlock->hash < tdb->tdb1.header.hash_size; tlock->hash++) {
- if (!tlock->off && tlock->hash != 0) {
- /* this is an optimisation for the common case where
- the hash chain is empty, which is particularly
- common for the use of tdb with ldb, where large
- hashes are used. In that case we spend most of our
- time in tdb1_brlock(), locking empty hash chains.
-
- To avoid this, we do an unlocked pre-check to see
- if the hash chain is empty before starting to look
- inside it. If it is empty then we can avoid that
- hash chain. If it isn't empty then we can't believe
- the value we get back, as we read it without a
- lock, so instead we get the lock and re-fetch the
- value below.
-
- Notice that not doing this optimisation on the
- first hash chain is critical. We must guarantee
- that we have done at least one fcntl lock at the
- start of a search to guarantee that memory is
- coherent on SMP systems. If records are added by
- others during the search then thats OK, and we
- could possibly miss those with this trick, but we
- could miss them anyway without this trick, so the
- semantics don't change.
-
- With a non-indexed ldb search this trick gains us a
- factor of around 80 in speed on a linux 2.6.x
- system (testing using ldbtest).
- */
- tdb->tdb1.io->next_hash_chain(tdb, &tlock->hash);
- if (tlock->hash == tdb->tdb1.header.hash_size) {
- continue;
- }
- }
-
- if (tdb1_lock(tdb, tlock->hash, tlock->lock_rw) == -1)
- return TDB1_NEXT_LOCK_ERR;
-
- /* No previous record? Start at top of chain. */
- if (!tlock->off) {
- if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(tlock->hash),
- &tlock->off) == -1)
- goto fail;
- } else {
- /* Otherwise unlock the previous record. */
- if (tdb1_unlock_record(tdb, tlock->off) != 0)
- goto fail;
- }
-
- if (want_next) {
- /* We have offset of old record: grab next */
- if (tdb1_rec_read(tdb, tlock->off, rec) == -1)
- goto fail;
- tlock->off = rec->next;
- }
-
- /* Iterate through chain */
- while( tlock->off) {
- tdb1_off_t current;
- if (tdb1_rec_read(tdb, tlock->off, rec) == -1)
- goto fail;
-
- /* Detect infinite loops. From "Shlomi Yaakobovich" <Shlomi@exanet.com>. */
- if (tlock->off == rec->next) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
- TDB_LOG_ERROR,
- "tdb1_next_lock:"
- " loop detected.");
- goto fail;
- }
-
- if (!TDB1_DEAD(rec)) {
- /* Woohoo: we found one! */
- if (tdb1_lock_record(tdb, tlock->off) != 0)
- goto fail;
- return tlock->off;
- }
-
- /* Try to clean dead ones from old traverses */
- current = tlock->off;
- tlock->off = rec->next;
- if (!((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) &&
- tdb1_do_delete(tdb, current, rec) != 0)
- goto fail;
- }
- tdb1_unlock(tdb, tlock->hash, tlock->lock_rw);
- want_next = 0;
- }
- /* We finished iteration without finding anything */
- tdb->last_error = TDB_SUCCESS;
- return 0;
-
- fail:
- tlock->off = 0;
- if (tdb1_unlock(tdb, tlock->hash, tlock->lock_rw) != 0)
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_next_lock: On error unlock failed!");
- return TDB1_NEXT_LOCK_ERR;
-}
-
-/* traverse the entire database - calling fn(tdb, key, data) on each element.
- return -1 on error or the record count traversed
- if fn is NULL then it is not called
- a non-zero return value from fn() indicates that the traversal should stop
- */
-static int tdb1_traverse_internal(struct tdb_context *tdb,
- int (*fn)(struct tdb_context *,
- TDB_DATA, TDB_DATA, void *),
- void *private_data,
- struct tdb1_traverse_lock *tl)
-{
- TDB_DATA key, dbuf;
- struct tdb1_record rec;
- int ret = 0, count = 0;
- tdb1_off_t off;
-
- /* This was in the initializaton, above, but the IRIX compiler
- * did not like it. crh
- */
- tl->next = tdb->tdb1.travlocks.next;
-
- /* fcntl locks don't stack: beware traverse inside traverse */
- tdb->tdb1.travlocks.next = tl;
-
- /* tdb1_next_lock places locks on the record returned, and its chain */
- while ((off = tdb1_next_lock(tdb, tl, &rec)) != 0) {
- if (off == TDB1_NEXT_LOCK_ERR) {
- ret = -1;
- goto out;
- }
- count++;
- /* now read the full record */
- key.dptr = tdb1_alloc_read(tdb, tl->off + sizeof(rec),
- rec.key_len + rec.data_len);
- if (!key.dptr) {
- ret = -1;
- if (tdb1_unlock(tdb, tl->hash, tl->lock_rw) != 0)
- goto out;
- if (tdb1_unlock_record(tdb, tl->off) != 0)
- 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;
- dbuf.dptr = key.dptr + rec.key_len;
- dbuf.dsize = rec.data_len;
-
- /* Drop chain lock, call out */
- if (tdb1_unlock(tdb, tl->hash, tl->lock_rw) != 0) {
- ret = -1;
- SAFE_FREE(key.dptr);
- goto out;
- }
- if (fn && fn(tdb, key, dbuf, private_data)) {
- /* They want us to terminate traversal */
- if (tdb1_unlock_record(tdb, tl->off) != 0) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_traverse:"
- " unlock_record failed!");
- ret = -1;
- }
- SAFE_FREE(key.dptr);
- goto out;
- }
- SAFE_FREE(key.dptr);
- }
-out:
- tdb->tdb1.travlocks.next = tl->next;
- if (ret < 0)
- return -1;
- else
- return count;
-}
-
-
-/*
- a read style traverse - only if db read only
-*/
-static int tdb1_traverse_read(struct tdb_context *tdb,
- int (*fn)(struct tdb_context *,
- TDB_DATA, TDB_DATA, void *),
- void *private_data)
-{
- struct tdb1_traverse_lock tl = { NULL, 0, 0, F_RDLCK };
- int ret;
-
- /* we need to get a read lock on the transaction lock here to
- cope with the lock ordering semantics of solaris10 */
- if (tdb1_transaction_lock(tdb, F_RDLCK, TDB_LOCK_WAIT)) {
- return -1;
- }
-
- tdb->tdb1.traverse_read++;
- ret = tdb1_traverse_internal(tdb, fn, private_data, &tl);
- tdb->tdb1.traverse_read--;
-
- tdb1_transaction_unlock(tdb, F_RDLCK);
-
- return ret;
-}
-
-/*
- a write style traverse - needs to get the transaction lock to
- prevent deadlocks
-
- WARNING: The data buffer given to the callback fn does NOT meet the
- alignment restrictions malloc gives you.
-*/
-int tdb1_traverse(struct tdb_context *tdb,
- int (*fn)(struct tdb_context *, TDB_DATA, TDB_DATA, void *),
- void *private_data)
-{
- struct tdb1_traverse_lock tl = { NULL, 0, 0, F_WRLCK };
- int ret;
-
- /* If we're read-only, we don't have to write-lock whole db. */
- if (tdb->flags & TDB_RDONLY) {
- return tdb1_traverse_read(tdb, fn, private_data);
- }
-
- if (tdb1_transaction_lock(tdb, F_WRLCK, TDB_LOCK_WAIT)) {
- return -1;
- }
-
- tdb->tdb1.traverse_write++;
- ret = tdb1_traverse_internal(tdb, fn, private_data, &tl);
- tdb->tdb1.traverse_write--;
-
- tdb1_transaction_unlock(tdb, F_WRLCK);
-
- return ret;
-}
-
-
-/* find the first entry in the database and return its key */
-TDB_DATA tdb1_firstkey(struct tdb_context *tdb)
-{
- TDB_DATA key;
- struct tdb1_record rec;
- tdb1_off_t off;
-
- /* release any old lock */
- if (tdb1_unlock_record(tdb, tdb->tdb1.travlocks.off) != 0)
- return tdb1_null;
- tdb->tdb1.travlocks.off = tdb->tdb1.travlocks.hash = 0;
- tdb->tdb1.travlocks.lock_rw = F_RDLCK;
-
- /* Grab first record: locks chain and returned record. */
- off = tdb1_next_lock(tdb, &tdb->tdb1.travlocks, &rec);
- if (off == 0 || off == TDB1_NEXT_LOCK_ERR) {
- return tdb1_null;
- }
- /* now read the key */
- key.dsize = rec.key_len;
- key.dptr =tdb1_alloc_read(tdb,tdb->tdb1.travlocks.off+sizeof(rec),key.dsize);
-
- /* Unlock the hash chain of the record we just read. */
- if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0)
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_firstkey:"
- " error occurred while tdb1_unlocking!");
- return key;
-}
-
-/* find the next entry in the database, returning its key */
-TDB_DATA tdb1_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
-{
- uint32_t oldhash;
- TDB_DATA key = tdb1_null;
- struct tdb1_record rec;
- unsigned char *k = NULL;
- tdb1_off_t off;
-
- /* Is locked key the old key? If so, traverse will be reliable. */
- if (tdb->tdb1.travlocks.off) {
- if (tdb1_lock(tdb,tdb->tdb1.travlocks.hash,tdb->tdb1.travlocks.lock_rw))
- return tdb1_null;
- if (tdb1_rec_read(tdb, tdb->tdb1.travlocks.off, &rec) == -1
- || !(k = tdb1_alloc_read(tdb,tdb->tdb1.travlocks.off+sizeof(rec),
- rec.key_len))
- || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
- /* No, it wasn't: unlock it and start from scratch */
- if (tdb1_unlock_record(tdb, tdb->tdb1.travlocks.off) != 0) {
- SAFE_FREE(k);
- return tdb1_null;
- }
- if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0) {
- SAFE_FREE(k);
- return tdb1_null;
- }
- tdb->tdb1.travlocks.off = 0;
- }
-
- SAFE_FREE(k);
- }
-
- if (!tdb->tdb1.travlocks.off) {
- /* No previous element: do normal find, and lock record */
- tdb->tdb1.travlocks.off = tdb1_find_lock_hash(tdb, oldkey, tdb_hash(tdb, oldkey.dptr, oldkey.dsize), tdb->tdb1.travlocks.lock_rw, &rec);
- if (!tdb->tdb1.travlocks.off) {
- return tdb1_null;
- }
- tdb->tdb1.travlocks.hash = TDB1_BUCKET(rec.full_hash);
- if (tdb1_lock_record(tdb, tdb->tdb1.travlocks.off) != 0) {
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_nextkey: lock_record failed (%s)!",
- strerror(errno));
- return tdb1_null;
- }
- }
- oldhash = tdb->tdb1.travlocks.hash;
-
- /* Grab next record: locks chain and returned record,
- unlocks old record */
- off = tdb1_next_lock(tdb, &tdb->tdb1.travlocks, &rec);
- if (off != TDB1_NEXT_LOCK_ERR && off != 0) {
- key.dsize = rec.key_len;
- key.dptr = tdb1_alloc_read(tdb, tdb->tdb1.travlocks.off+sizeof(rec),
- key.dsize);
- /* Unlock the chain of this new record */
- if (tdb1_unlock(tdb, tdb->tdb1.travlocks.hash, tdb->tdb1.travlocks.lock_rw) != 0)
- 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->tdb1.travlocks.lock_rw) != 0)
- tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
- "tdb1_nextkey: WARNING tdb1_unlock failed!");
- return key;
-}
#define TDB_SEQNUM 128 /* maintain a sequence number */
#define TDB_ALLOW_NESTING 256 /* fake nested transactions */
#define TDB_RDONLY 512 /* implied by O_RDONLY */
-#define TDB_VERSION1 1024 /* create/open an old style TDB */
#define TDB_CANT_CHECK 2048 /* has a feature which we don't understand */
-/**
- * tdb1_incompatible_hash - better (Jenkins) hash for tdb1
- *
- * This is better than the default hash for tdb1; but older versions of the
- * tdb library (prior to version 1.2.6) won't be able to open them.
- *
- * It only makes sense to specify this (using tdb_attribute_hash) when
- * creating (with O_CREAT) an old tdb version using TDB_VERSION1. It's
- * equivalent to the TDB_INCOMPATIBLE_HASH flag for tdb1.
- */
-uint64_t tdb1_incompatible_hash(const void *, size_t, uint64_t, void *);
-
/**
* tdb_close - close and free a tdb.
* @tdb: the tdb context returned from tdb_open()
TDB_ATTRIBUTE_STATS = 3,
TDB_ATTRIBUTE_OPENHOOK = 4,
TDB_ATTRIBUTE_FLOCK = 5,
- TDB_ATTRIBUTE_TDB1_HASHSIZE = 128,
- TDB_ATTRIBUTE_TDB1_MAX_DEAD = 129,
};
/**
* of the same type. It returns TDB_ERR_EINVAL if the attribute is
* unknown or invalid.
*
- * Note that TDB_ATTRIBUTE_HASH, TDB_ATTRIBUTE_SEED,
- * TDB_ATTRIBUTE_OPENHOOK and TDB_ATTRIBUTE_TDB1_HASHSIZE cannot
- * currently be set after tdb_open.
+ * Note that TDB_ATTRIBUTE_HASH, TDB_ATTRIBUTE_SEED, and
+ * TDB_ATTRIBUTE_OPENHOOK cannot currently be set after tdb_open.
*/
enum TDB_ERROR tdb_set_attribute(struct tdb_context *tdb,
const union tdb_attribute *attr);
void *data;
};
-/**
- * struct tdb_attribute_tdb1_hashsize - tdb1 hashsize
- *
- * This attribute allows setting the TDB1 hashsize; it only makes sense with
- * O_CREAT and TDB_VERSION1.
- *
- * Hashsize should generally be a prime, such as 10007.
- */
-struct tdb_attribute_tdb1_hashsize {
- struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_TDB1_HASHSIZE */
- unsigned int hsize;
-};
-
-/**
- * struct tdb_attribute_tdb1_max_dead - tdb1 number of maximum dead records.
- *
- * TDB1 has a method to speed up its slow free list: it lets a certain
- * number of "dead" records build up before freeing them. This is
- * particularly useful for volatile TDBs; setting it to 5 is
- * equivalent to tdb1's TDB_VOLATILE flag.
- */
-struct tdb_attribute_tdb1_max_dead {
- struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_TDB1_MAX_DEAD */
- unsigned int max_dead;
-};
-
/**
* union tdb_attribute - tdb attributes.
*
struct tdb_attribute_stats stats;
struct tdb_attribute_openhook openhook;
struct tdb_attribute_flock flock;
- struct tdb_attribute_tdb1_hashsize tdb1_hashsize;
- struct tdb_attribute_tdb1_max_dead tdb1_max_dead;
};
#ifdef __cplusplus
.data = &seed } };
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
/* These two values gave trouble before. */
int vals[] = { 755, 837 };
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 2 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 4 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 2 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
struct tdb_context *tdb;
unsigned char *buffer;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data;
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 3);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
struct tdb_data data = tdb_mkdata("data", 4);
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
- plan_tests(sizeof(flags) / sizeof(flags[0]) * 15 + 8 * 13);
+ plan_tests(sizeof(flags) / sizeof(flags[0]) * 15 + 4 * 13);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
tdb = tdb_open("api-81-seqnum.tdb", flags[i]|TDB_SEQNUM,
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
free(d.dptr);
ok1(tdb_get_seqnum(tdb) == seq);
ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);
- /* Append in tdb1 (or store over value) bumps twice! */
- if (flags[i] & TDB_VERSION1)
- seq++;
ok1(tdb_get_seqnum(tdb) == ++seq);
ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
ok1(tdb_get_seqnum(tdb) == ++seq);
- /* Append in tdb1 (or store over value) bumps twice! */
- if (flags[i] & TDB_VERSION1)
- seq++;
ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);
ok1(tdb_get_seqnum(tdb) == ++seq);
ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
union tdb_attribute lock_attr;
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
struct tdb_data d;
- unsigned int num_oom_messages;
-
- /* TDB1 double logs here. */
- if (flags[i] & TDB_VERSION1) {
- num_oom_messages = 2;
- } else {
- num_oom_messages = 1;
- }
/* Nonblocking open; expect no error message. */
lock_err = EAGAIN;
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(tdb_store(tdb, key, data, TDB_REPLACE) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
/* Nonblocking fetch. */
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(!tdb_exists(tdb, key));
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
lock_err = EAGAIN;
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(tdb_fetch(tdb, key, &d) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
/* Nonblocking delete. */
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(tdb_delete(tdb, key) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
/* Nonblocking locks. */
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(tdb_chainlock(tdb, key) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
lock_err = EAGAIN;
ok1(tap_log_messages == 0);
lock_err = ENOMEM;
ok1(tdb_chainlock_read(tdb, key) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
lock_err = EAGAIN;
trav_err = ENOMEM;
lock_err = 0;
ok1(tdb_traverse(tdb, trav, &lock_err) == TDB_ERR_LOCK);
- ok1(tap_log_messages == num_oom_messages);
+ ok1(tap_log_messages == 1);
tap_log_messages = 0;
/* Nonblocking transactions. */
union tdb_attribute cif;
struct tdb_data key = tdb_mkdata("key", 3);
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
cif.openhook.base.attr = TDB_ATTRIBUTE_OPENHOOK;
cif.openhook.base.next = &tap_log_attr;
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 11);
int main(int argc, char *argv[])
{
- unsigned int i, extra_msgs;
+ unsigned int i;
struct tdb_context *tdb;
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 48);
ok1(tdb);
ok1(!(tdb_get_flags(tdb) & TDB_RDONLY));
- /* TDB1 complains multiple times. */
- if (flags[i] & TDB_VERSION1) {
- extra_msgs = 1;
- } else {
- extra_msgs = 0;
- }
-
ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
tdb_add_flag(tdb, TDB_RDONLY);
ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 1);
ok1(tdb_append(tdb, key, data) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 2);
ok1(tdb_delete(tdb, key) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 3);
/* Can't start a transaction, or any write lock. */
ok1(tdb_transaction_start(tdb) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 4);
ok1(tdb_chainlock(tdb, key) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 5);
ok1(tdb_lockall(tdb) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 6);
ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 8);
ok1(tdb_append(tdb, key, data) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 9);
ok1(tdb_delete(tdb, key) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 10);
/* Can't start a transaction, or any write lock. */
ok1(tdb_transaction_start(tdb) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 11);
ok1(tdb_chainlock(tdb, key) == TDB_ERR_RDONLY);
- tap_log_messages -= extra_msgs;
ok1(tap_log_messages == 12);
ok1(tdb_lockall(tdb) == TDB_ERR_RDONLY);
ok1(tap_log_messages == 13);
bool found[NUM_TESTS];
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_VERSION1|TDB_NOMMAP,
- TDB_VERSION1|TDB_CONVERT,
- TDB_VERSION1|TDB_NOMMAP|TDB_CONVERT
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT
};
plan_tests(sizeof(flags) / sizeof(flags[0]) * 6 + 1);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
- plan_tests(173);
+ plan_tests(87);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
tdb = tdb_open("run-add-remove-flags.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 4 + 1);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
enum TDB_ERROR ecode;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
seed_attr.base.attr = TDB_ATTRIBUTE_SEED;
seed_attr.base.next = &tap_log_attr;
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
tdb = tdb_open("api-firstkey-nextkey.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600,
- flags[i] & TDB_VERSION1 ? NULL : &seed_attr);
+ &seed_attr);
ok1(tdb);
if (!tdb)
continue;
static enum TDB_ERROR fork_in_parse(TDB_DATA key, TDB_DATA data,
struct tdb_context *tdb)
{
- int status, extra_messages;
-
- if (tdb_get_flags(tdb) & TDB_VERSION1) {
- extra_messages = 1;
- } else {
- extra_messages = 0;
- }
+ int status;
if (fork() == 0) {
/* We expect this to fail. */
if (tdb_store(tdb, key, data, TDB_REPLACE) != TDB_ERR_LOCK)
exit(1);
- tap_log_messages -= extra_messages;
if (tdb_fetch(tdb, key, &data) != TDB_ERR_LOCK)
exit(1);
- tap_log_messages -= extra_messages;
if (tap_log_messages != 2)
exit(2);
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
- int status, extra_messages;
-
- if (flags[i] & TDB_VERSION1) {
- extra_messages = 1;
- } else {
- extra_messages = 0;
- }
+ int status;
tap_log_messages = 0;
/* We expect this to fail. */
if (tdb_store(tdb, key, data, TDB_REPLACE) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tdb_fetch(tdb, key, &data) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tap_log_messages != 2)
return 2;
/* We expect this to fail. */
if (tdb_store(tdb, key, data, TDB_REPLACE) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tdb_fetch(tdb, key, &data) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tap_log_messages != 2)
return 2;
/* This would always fail anyway... */
if (tdb_store(tdb, key, data, TDB_REPLACE) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tdb_fetch(tdb, key, &data) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tap_log_messages != 2)
return 2;
/* We expect this to fail. */
if (tdb_store(tdb, key, data, TDB_REPLACE) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tdb_fetch(tdb, key, &data) != TDB_ERR_LOCK)
return 1;
- tap_log_messages -= extra_messages;
if (tap_log_messages != 2)
return 2;
if (tdb_transaction_commit(tdb) != TDB_ERR_LOCK)
return 3;
- tap_log_messages -= extra_messages;
tdb_close(tdb);
if (tap_log_messages < 3)
struct tdb_context *tdb;
TDB_DATA key = tdb_mkdata("hello", 5);
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
struct agent *agent;
plan_tests(sizeof(flags) / sizeof(flags[0]) * 15);
int main(int argc, char *argv[])
{
- unsigned int i, extra_messages;
+ unsigned int i;
struct tdb_context *tdb, *tdb2;
struct tdb_data key = { (unsigned char *)&i, sizeof(i) };
struct tdb_data data = { (unsigned char *)&i, sizeof(i) };
struct tdb_data d = { NULL, 0 }; /* Bogus GCC warning */
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
plan_tests(sizeof(flags) / sizeof(flags[0]) * 28);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
if (!tdb)
continue;
- if (flags[i] & TDB_VERSION1) {
- extra_messages = 1;
- } else {
- extra_messages = 0;
- }
tdb2 = tdb_open("run-open-multiple-times.tdb", flags[i],
O_RDWR|O_CREAT, 0600, &tap_log_attr);
ok1(tdb_check(tdb, NULL, NULL) == 0);
/* Anything in the other one should fail. */
ok1(tdb_fetch(tdb, key, &d) == TDB_ERR_LOCK);
- tap_log_messages -= extra_messages;
ok1(tap_log_messages == 1);
ok1(tdb_store(tdb, key, data, TDB_REPLACE) == TDB_ERR_LOCK);
- tap_log_messages -= extra_messages;
ok1(tap_log_messages == 2);
ok1(tdb_transaction_start(tdb) == TDB_ERR_LOCK);
ok1(tap_log_messages == 3);
ok1(tdb_chainlock(tdb, key) == TDB_ERR_LOCK);
- tap_log_messages -= extra_messages;
ok1(tap_log_messages == 4);
/* Transaciton should work as normal. */
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data;
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = { (unsigned char *)&j, sizeof(j) };
struct tdb_data data = { (unsigned char *)&j, sizeof(j) };
char *summary;
ok1(strstr(summary, "Number of records: 500\n"));
ok1(strstr(summary, "Smallest/average/largest keys: 4/4/4\n"));
ok1(strstr(summary, "Smallest/average/largest data: 0/2/4\n"));
- if (!(flags[i] & TDB_VERSION1)
- && j == TDB_SUMMARY_HISTOGRAMS) {
+ if (j == TDB_SUMMARY_HISTOGRAMS) {
ok1(strstr(summary, "|")
&& strstr(summary, "*"));
} else {
+++ /dev/null
-#include "config.h"
-#include "tdb2.h"
-#include "tap-interface.h"
-#include <ccan/hash/hash.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- unsigned int i;
- struct tdb_context *tdb;
- int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
-
- plan_tests(sizeof(flags) / sizeof(flags[0]) * 3 + 1);
- for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
- tdb = tdb_open("run-12-store.tdb", flags[i],
- O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
- if (!ok1(tdb))
- continue;
-
- tdb_close(tdb);
-
- tdb = tdb_open("run-12-store.tdb", flags[i] | TDB_VERSION1,
- O_RDWR, 0600, &tap_log_attr);
- if (!ok1(tdb))
- continue;
- /* It's not a version1 */
- ok1(!(tdb_get_flags(tdb) & TDB_VERSION1));
-
- tdb_close(tdb);
- }
-
- ok1(tap_log_messages == 0);
- return exit_status();
-}
#include <stdbool.h>
/* FIXME: Check these! */
-#define INITIAL_TDB_MALLOC "open.c", 445, FAILTEST_MALLOC
+#define INITIAL_TDB_MALLOC "open.c", 403, FAILTEST_MALLOC
#define URANDOM_OPEN "open.c", 62, FAILTEST_OPEN
#define URANDOM_READ "open.c", 42, FAILTEST_READ
#include "external-agent.h"
-#include "tdb1_private.h"
/* This isn't possible with via the tdb2 API, but this makes it link. */
enum agent_return external_agent_needs_rec(struct tdb_context *tdb)
#include "external-agent.h"
-#include "tdb1_private.h"
+#include "private.h"
enum agent_return external_agent_needs_rec(struct tdb_context *tdb)
{
- if (tdb->flags & TDB_VERSION1)
- return tdb1_needs_recovery(tdb) ? SUCCESS : FAILED;
- else
- return tdb_needs_recovery(tdb) ? SUCCESS : FAILED;
+ return tdb_needs_recovery(tdb) ? SUCCESS : FAILED;
}
/* We save the locks so we can reaquire them. */
-#include "tdb1_private.h" /* For TDB_HASH_LOCK_START, TDB1_FREELIST_TOP, etc. */
+#include "private.h" /* For TDB_HASH_LOCK_START, etc. */
#include <unistd.h>
#include <fcntl.h>
#include <stdarg.h>
i->type = F_WRLCK;
goto done;
}
- /* allrecord upgrade for tdb1. */
- if (i->type == F_RDLCK && fl->l_type == F_WRLCK
- && i->off == TDB1_FREELIST_TOP
- && fl->l_start == TDB1_FREELIST_TOP
- && i->len == 0
- && fl->l_len == 0) {
- if (ret == 0)
- i->type = F_WRLCK;
- goto done;
- }
-
if (!suppress_lockcheck) {
diag("%s lock %u@%u overlaps %u@%u",
fl->l_type == F_WRLCK ? "write" : "read",
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
failtest_init(argc, argv);
failtest_hook = block_repeat_failures;
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4), d;
union tdb_attribute seed_attr;
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
tdb = tdb_open("run-05-readonly-open.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600,
- flags[i] & TDB_VERSION1
- ? &tap_log_attr : &seed_attr);
+ &seed_attr);
ok1(tdb_store(tdb, key, data, TDB_INSERT) == 0);
tdb_close(tdb);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
struct tdb_context *tdb;
int flags[] = { TDB_INTERNAL,
TDB_INTERNAL|TDB_CONVERT,
- TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1,
- TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
struct tdb_used_record urec;
struct hash_info h;
- if (tdb_get_flags(tdb) & TDB_VERSION1) {
- struct tdb1_record rec;
- return tdb1_find(tdb, key, tdb_hash(tdb, key.dptr, key.dsize),
- &rec);
- }
-
off = find_and_lock(tdb, key, F_RDLCK, &h, &urec, NULL);
if (TDB_OFF_IS_ERR(off))
return 0;
tdb_off_t oldoff = 0, newoff;
int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT,
- TDB_INTERNAL|TDB_VERSION1, TDB_VERSION1,
- TDB_NOMMAP|TDB_VERSION1,
- TDB_INTERNAL|TDB_CONVERT|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data;
}
ok1(!tdb->file || (tdb->file->allrecord_lock.count == 0
&& tdb->file->num_lockrecs == 0));
- if (flags[i] & TDB_VERSION1) {
- /* TDB1 simply over-size by 25%. */
- ok(moves <= ilog64(j / SIZE_STEP)*4,
- "Moved %u times", moves);
- } else {
- /* We should increase by 50% each time... */
- ok(moves <= ilog64(j / SIZE_STEP)*2,
- "Moved %u times", moves);
- }
+ /* We should increase by 50% each time... */
+ ok(moves <= ilog64(j / SIZE_STEP)*2,
+ "Moved %u times", moves);
tdb_close(tdb);
}
}
ok1(!tdb->file || (tdb->file->allrecord_lock.count == 0
&& tdb->file->num_lockrecs == 0));
- if (flags[i] & TDB_VERSION1) {
- /* TDB1 simply over-size by 25%. */
- ok(moves <= ilog64(j / SIZE_STEP)*4,
- "Moved %u times", moves);
- } else {
- /* We should increase by 50% each time... */
- ok(moves <= ilog64(j / SIZE_STEP)*2,
- "Moved %u times", moves);
- }
+ /* We should increase by 50% each time... */
+ ok(moves <= ilog64(j / SIZE_STEP)*2,
+ "Moved %u times", moves);
tdb_close(tdb);
}
unsigned int i, messages = 0;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
failtest_init(argc, argv);
failtest_hook = block_repeat_failures;
int main(int argc, char *argv[])
{
const int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
int i;
struct tdb_context *tdb;
TDB_DATA key, data;
return ret;
}
-static bool test_death(enum operation op, struct agent *agent, int flags)
+static bool test_death(enum operation op, struct agent *agent)
{
struct tdb_context *tdb = NULL;
TDB_DATA key;
current = target = 0;
reset:
unlink(TEST_DBNAME);
- tdb = tdb_open(TEST_DBNAME, flags|TDB_NOMMAP,
+ tdb = tdb_open(TEST_DBNAME, TDB_NOMMAP,
O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
if (!tdb) {
diag("Failed opening TDB: %s", strerror(errno));
{
enum operation ops[] = { FETCH, STORE, TRANSACTION_START };
struct agent *agent;
- int i, flags;
+ int i;
- plan_tests(24);
+ plan_tests(12);
unlock_callback = maybe_die;
external_agent_free = free_noleak;
if (!agent)
err(1, "preparing agent");
- for (flags = TDB_DEFAULT; flags <= TDB_VERSION1; flags += TDB_VERSION1) {
- for (i = 0; i < sizeof(ops)/sizeof(ops[0]); i++) {
- diag("Testing %s after death", operation_name(ops[i]));
- ok1(test_death(ops[i], agent, flags));
- }
+ for (i = 0; i < sizeof(ops)/sizeof(ops[0]); i++) {
+ diag("Testing %s after death", operation_name(ops[i]));
+ ok1(test_death(ops[i], agent));
}
free_external_agent(agent);
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
union tdb_attribute seed_attr;
union tdb_attribute hash_attr;
union tdb_attribute lock_attr;
lock_attr.flock.unlock = myunlock;
lock_attr.flock.data = &lock_attr;
- plan_tests(sizeof(flags) / sizeof(flags[0]) * 49
- + sizeof(flags) / sizeof(flags[0]) / 2);
+ plan_tests(sizeof(flags) / sizeof(flags[0]) * 50);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
union tdb_attribute attr;
attr.base.attr = TDB_ATTRIBUTE_HASH;
ok1(tdb_get_attribute(tdb, &attr) == 0);
ok1(attr.base.attr == TDB_ATTRIBUTE_HASH);
- if (flags[i] & TDB_VERSION1) {
- ok1(attr.hash.fn == tdb1_old_hash);
- } else {
- ok1(attr.hash.fn == tdb_jenkins_hash);
- }
+ ok1(attr.hash.fn == tdb_jenkins_hash);
attr.base.attr = TDB_ATTRIBUTE_FLOCK;
ok1(tdb_get_attribute(tdb, &attr) == 0);
ok1(attr.base.attr == TDB_ATTRIBUTE_FLOCK);
ok1(attr.flock.lock == tdb_fcntl_lock);
ok1(attr.flock.unlock == tdb_fcntl_unlock);
attr.base.attr = TDB_ATTRIBUTE_SEED;
- if (flags[i] & TDB_VERSION1) {
- ok1(tdb_get_attribute(tdb, &attr) == TDB_ERR_EINVAL);
- tap_log_messages = 0;
- } else {
- ok1(tdb_get_attribute(tdb, &attr) == 0);
- ok1(attr.base.attr == TDB_ATTRIBUTE_SEED);
- /* This is possible, just astronomically unlikely. */
- ok1(attr.seed.seed != 0);
- }
+ ok1(tdb_get_attribute(tdb, &attr) == 0);
+ ok1(attr.base.attr == TDB_ATTRIBUTE_SEED);
+ /* This is possible, just astronomically unlikely. */
+ ok1(attr.seed.seed != 0);
/* Unset attributes. */
tdb_unset_attribute(tdb, TDB_ATTRIBUTE_LOG);
O_RDWR|O_CREAT|O_TRUNC, 0600,
&seed_attr);
- if (flags[i] & TDB_VERSION1) {
- ok1(!tdb);
- ok1(tap_log_messages == 1);
- tap_log_messages = 0;
- tdb = tdb_open("run-90-get-set-attributes.tdb", flags[i],
- O_RDWR|O_CREAT|O_TRUNC, 0600,
- &hash_attr);
- }
ok1(tdb);
/* Get will succeed */
ok1(attr.flock.data == &lock_attr);
attr.base.attr = TDB_ATTRIBUTE_SEED;
- if (flags[i] & TDB_VERSION1) {
- ok1(tdb_get_attribute(tdb, &attr) == TDB_ERR_EINVAL);
- ok1(tap_log_messages == 1);
- tap_log_messages = 0;
- } else {
- ok1(tdb_get_attribute(tdb, &attr) == 0);
- ok1(attr.base.attr == TDB_ATTRIBUTE_SEED);
- ok1(attr.seed.seed == seed_attr.seed.seed);
- }
+ ok1(tdb_get_attribute(tdb, &attr) == 0);
+ ok1(attr.base.attr == TDB_ATTRIBUTE_SEED);
+ ok1(attr.seed.seed == seed_attr.seed.seed);
/* Unset attributes. */
tdb_unset_attribute(tdb, TDB_ATTRIBUTE_HASH);
unsigned int i;
struct tdb_context *tdb;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
struct tdb_data key = tdb_mkdata("key", 3);
struct tdb_data data = tdb_mkdata("data", 4);
{
struct agent *agent;
int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT,
- TDB_VERSION1, TDB_NOMMAP|TDB_VERSION1,
- TDB_CONVERT|TDB_VERSION1,
- TDB_NOMMAP|TDB_CONVERT|TDB_VERSION1 };
+ TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
int i;
plan_tests(13 * sizeof(flags)/sizeof(flags[0]) + 1);
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-static int tdb1_expand_file_sparse(struct tdb_context *tdb,
- tdb1_off_t size,
- tdb1_off_t addition)
-{
- if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
- tdb->last_error = TDB_ERR_RDONLY;
- return -1;
- }
-
- if (ftruncate(tdb->file->fd, size+addition) == -1) {
- char b = 0;
- ssize_t written = pwrite(tdb->file->fd, &b, 1, (size+addition) - 1);
- if (written == 0) {
- /* try once more, potentially revealing errno */
- written = pwrite(tdb->file->fd, &b, 1, (size+addition) - 1);
- }
- if (written == 0) {
- /* again - give up, guessing errno */
- errno = ENOSPC;
- }
- if (written != 1) {
- tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "expand_file to %d failed (%s)",
- size+addition,
- strerror(errno));
- return -1;
- }
- }
-
- return 0;
-}
-
-static const struct tdb1_methods large_io_methods = {
- tdb1_read,
- tdb1_write,
- tdb1_next_hash_chain,
- tdb1_oob,
- tdb1_expand_file_sparse
-};
-
-static int test_traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *_data)
-{
- TDB_DATA *expect = _data;
- ok1(key.dsize == strlen("hi"));
- ok1(memcmp(key.dptr, "hi", strlen("hi")) == 0);
- ok1(data.dsize == expect->dsize);
- ok1(memcmp(data.dptr, expect->dptr, data.dsize) == 0);
- return 0;
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, orig_data, data;
- uint32_t hash;
- tdb1_off_t rec_ptr;
- struct tdb1_record rec;
- union tdb_attribute hsize;
- int ret;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(26);
- tdb = tdb_open("run-36-file.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- ok1(tdb);
- tdb->tdb1.io = &large_io_methods;
-
- key = tdb_mkdata("hi", strlen("hi"));
- orig_data = tdb_mkdata("world", strlen("world"));
-
- /* Enlarge the file (internally multiplies by 2). */
- ret = tdb1_expand(tdb, 1500000000);
-
-#ifdef HAVE_INCOHERENT_MMAP
- /* This can fail due to mmap failure on 32 bit systems. */
- if (ret == -1) {
- /* These should now fail. */
- ok1(tdb_store(tdb, key, orig_data, TDB_INSERT) == TDB_ERR_IO);
- ok1(tdb_fetch(tdb, key, &data) == TDB_ERR_IO);
- ok1(tdb_traverse(tdb, test_traverse, &orig_data) == TDB_ERR_IO);
- ok1(tdb_delete(tdb, key) == TDB_ERR_IO);
- ok1(tdb_traverse(tdb, test_traverse, NULL) == TDB_ERR_IO);
- /* Skip the rest... */
- for (ret = 0; ret < 26 - 6; ret++)
- ok1(1);
- tdb_close(tdb);
- return exit_status();
- }
-#endif
- ok1(ret == 0);
-
- /* Put an entry in, and check it. */
- ok1(tdb_store(tdb, key, orig_data, TDB_INSERT) == TDB_SUCCESS);
-
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
-
- /* That currently fills at the end, make sure that's true. */
- hash = tdb_hash(tdb, key.dptr, key.dsize);
- rec_ptr = tdb1_find_lock_hash(tdb, key, hash, F_RDLCK, &rec);
- ok1(rec_ptr);
- ok1(rec_ptr > 2U*1024*1024*1024);
- tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
-
- /* Traverse must work. */
- ok1(tdb_traverse(tdb, test_traverse, &orig_data) == 1);
-
- /* Delete should work. */
- ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
-
- ok1(tdb_traverse(tdb, test_traverse, NULL) == 0);
-
- /* Transactions should work. */
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_store(tdb, key, orig_data, TDB_INSERT) == TDB_SUCCESS);
-
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
-
- ok1(tdb_traverse(tdb, test_traverse, &orig_data) == 1);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- struct tdb1_header hdr;
- int fd;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(11);
- /* Cannot open fine if complete crap, even with O_CREAT. */
- fd = open("run-bad-tdb-header.tdb1", O_RDWR|O_CREAT|O_TRUNC, 0600);
- ok1(fd >= 0);
- ok1(write(fd, "hello world", 11) == 11);
- close(fd);
- tdb = tdb_open("run-bad-tdb-header.tdb1", 0, O_RDWR, 0, &tap_log_attr);
- ok1(!tdb);
- tdb = tdb_open("run-bad-tdb-header.tdb1", 0, O_CREAT|O_RDWR,
- 0600, &hsize);
- ok1(!tdb);
-
- /* With truncate, will be fine. */
- tdb = tdb_open("run-bad-tdb-header.tdb1", TDB_VERSION1,
- O_RDWR|O_CREAT|O_TRUNC, 0600, &hsize);
- ok1(tdb);
- tdb_close(tdb);
-
- /* Now, with wrong version it should *not* overwrite. */
- fd = open("run-bad-tdb-header.tdb1", O_RDWR);
- ok1(fd >= 0);
- ok1(read(fd, &hdr, sizeof(hdr)) == sizeof(hdr));
- ok1(hdr.version == TDB1_VERSION);
- hdr.version++;
- lseek(fd, 0, SEEK_SET);
- ok1(write(fd, &hdr, sizeof(hdr)) == sizeof(hdr));
- close(fd);
-
- tdb = tdb_open("run-bad-tdb-header.tdb1", TDB_VERSION1, O_RDWR|O_CREAT,
- 0600, &hsize);
- ok1(errno == EIO);
- ok1(!tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1;
-
- plan_tests(13);
- tdb = tdb_open("run-check.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
-
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("run-check.tdb1", TDB_VERSION1, O_RDWR, 0, &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("test/tdb1.corrupt", TDB_VERSION1, O_RDWR, 0,
- &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_ERR_CORRUPT);
- ok1(tdb_error(tdb) == TDB_ERR_CORRUPT);
- tdb_close(tdb);
-
- /* Big and little endian should work! */
- tdb = tdb_open("test/old-nohash-le.tdb1", TDB_VERSION1, O_RDWR, 0,
- &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("test/old-nohash-be.tdb1", TDB_VERSION1, O_RDWR, 0,
- &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-static int check(TDB_DATA key, TDB_DATA data, void *private)
-{
- unsigned int *sizes = private;
-
- if (key.dsize > strlen("hello"))
- return -1;
- if (memcmp(key.dptr, "hello", key.dsize) != 0)
- return -1;
-
- if (data.dsize != strlen("world"))
- return -1;
- if (memcmp(data.dptr, "world", data.dsize) != 0)
- return -1;
-
- sizes[0] += key.dsize;
- sizes[1] += data.dsize;
- return 0;
-}
-
-static void tdb1_flip_bit(struct tdb_context *tdb, unsigned int bit)
-{
- unsigned int off = bit / CHAR_BIT;
- unsigned char mask = (1 << (bit % CHAR_BIT));
-
- if (tdb->file->map_ptr)
- ((unsigned char *)tdb->file->map_ptr)[off] ^= mask;
- else {
- unsigned char c;
- if (pread(tdb->file->fd, &c, 1, off) != 1)
- err(1, "pread");
- c ^= mask;
- if (pwrite(tdb->file->fd, &c, 1, off) != 1)
- err(1, "pwrite");
- }
-}
-
-static void check_test(struct tdb_context *tdb)
-{
- TDB_DATA key, data;
- unsigned int i, verifiable, corrupt, sizes[2], dsize, ksize;
-
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
-
- key = tdb_mkdata("hello", strlen("hello"));
- data = tdb_mkdata("world", strlen("world"));
-
- /* Key and data size respectively. */
- dsize = ksize = 0;
-
- /* 5 keys in hash size 2 means we'll have multichains. */
- for (key.dsize = 1; key.dsize <= 5; key.dsize++) {
- ksize += key.dsize;
- dsize += data.dsize;
- if (tdb_store(tdb, key, data, TDB_INSERT) != TDB_SUCCESS)
- abort();
- }
-
- /* This is how many bytes we expect to be verifiable. */
- /* From the file header. */
- verifiable = strlen(TDB_MAGIC_FOOD) + 1
- + 2 * sizeof(uint32_t) + 2 * sizeof(tdb1_off_t)
- + 2 * sizeof(uint32_t);
- /* From the free list chain and hash chains. */
- verifiable += 3 * sizeof(tdb1_off_t);
- /* From the record headers & tailer */
- verifiable += 5 * (sizeof(struct tdb1_record) + sizeof(uint32_t));
- /* The free block: we ignore datalen, keylen, full_hash. */
- verifiable += sizeof(struct tdb1_record) - 3*sizeof(uint32_t) +
- sizeof(uint32_t);
- /* Our check function verifies the key and data. */
- verifiable += ksize + dsize;
-
- /* Flip one bit at a time, make sure it detects verifiable bytes. */
- for (i = 0, corrupt = 0; i < tdb->file->map_size * CHAR_BIT; i++) {
- tdb1_flip_bit(tdb, i);
- memset(sizes, 0, sizeof(sizes));
- if (tdb_check(tdb, check, sizes) == TDB_ERR_CORRUPT)
- corrupt++;
- else if (sizes[0] != ksize || sizes[1] != dsize)
- corrupt++;
- tdb1_flip_bit(tdb, i);
- }
- ok(corrupt == verifiable * CHAR_BIT, "corrupt %u should be %u",
- corrupt, verifiable * CHAR_BIT);
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 2;
-
- plan_tests(4);
- /* This should use mmap. */
- tdb = tdb_open("run-corrupt.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- if (!tdb)
- abort();
- check_test(tdb);
- tdb_close(tdb);
-
- /* This should not. */
- tdb = tdb_open("run-corrupt.tdb1", TDB_VERSION1|TDB_NOMMAP,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- if (!tdb)
- abort();
- check_test(tdb);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(14);
- tdb = tdb_open("run-endian.tdb1",
- TDB_VERSION1|TDB_CONVERT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- ok1(tdb);
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_ERR_NOEXIST);
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_ERR_EXISTS);
- ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_SUCCESS);
-
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
-
- key.dsize++;
- ok1(tdb_fetch(tdb, key, &data) == TDB_ERR_NOEXIST);
- ok1(data.dptr == NULL);
- tdb_close(tdb);
-
- /* Reopen: should read it */
- tdb = tdb_open("run-endian.tdb1", 0, O_RDWR, 0, NULL);
- ok1(tdb);
-
- key = tdb_mkdata("hi", strlen("hi"));
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- union tdb_attribute hsize, h2;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(14);
- tdb = tdb_open("run-tdb1-hashsize.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
- ok1(tdb);
- h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
- ok1(h2.tdb1_hashsize.hsize == hsize.tdb1_hashsize.hsize);
- tdb_close(tdb);
-
- /* Can't specify TDB_ATTRIBUTE_TDB1_HASHSIZE without O_CREAT */
- tdb = tdb_open("run-tdb1-hashsize.tdb1", TDB_VERSION1,
- O_RDWR, 0600, &hsize);
- ok1(!tdb);
- ok1(tap_log_messages == 1);
-
- /* Can't specify TDB_ATTRIBUTE_TDB1_HASHSIZE for version2. */
- tdb = tdb_open("run-tdb1-hashsize.tdb", TDB_DEFAULT,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
- ok1(!tdb);
- ok1(tap_log_messages == 2);
-
- /* We can get attribute even if we didn't set it though. */
- tdb = tdb_open("run-tdb1-hashsize.tdb1", TDB_DEFAULT,
- O_RDWR, 0600, &tap_log_attr);
-
- ok1(tdb);
- memset(&h2, 0, sizeof(h2));
- h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
- ok1(h2.tdb1_hashsize.hsize == hsize.tdb1_hashsize.hsize);
- tdb_close(tdb);
-
- /* Check for default hash size. */
- tdb = tdb_open("run-tdb1-hashsize.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &tap_log_attr);
-
- ok1(tdb);
- memset(&h2, 0, sizeof(h2));
- h2.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- ok1(tdb_get_attribute(tdb, &h2) == TDB_SUCCESS);
- ok1(h2.tdb1_hashsize.hsize == TDB1_DEFAULT_HASH_SIZE);
- tdb_close(tdb);
- ok1(tap_log_messages == 2);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-
-static uint64_t tdb1_dumb_hash(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return len;
-}
-
-static void log_fn(struct tdb_context *tdb, enum tdb_log_level level,
- enum TDB_ERROR ecode, const char *message, void *priv)
-{
- unsigned int *count = priv;
- if (strstr(message, "hash"))
- (*count)++;
-}
-
-static unsigned int hdr_rwlocks(const char *fname)
-{
- struct tdb1_header hdr;
-
- int fd = open(fname, O_RDONLY);
- if (fd == -1)
- return -1;
-
- if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr))
- return -1;
-
- close(fd);
- return hdr.rwlocks;
-}
-
-static uint64_t jenkins_hashfn(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return hashlittle(key, len);
-}
-
-static uint64_t old_hash(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return tdb1_old_hash(key, len, seed, unused);
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- unsigned int log_count, flags;
- TDB_DATA d;
- union tdb_attribute log_attr, jhash_attr, ohash_attr,
- incompat_hash_attr, dumbhash_attr;
-
- log_attr.base.attr = TDB_ATTRIBUTE_LOG;
- log_attr.base.next = NULL;
- log_attr.log.fn = log_fn;
- log_attr.log.data = &log_count;
-
- jhash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- jhash_attr.base.next = &log_attr;
- jhash_attr.hash.fn = jenkins_hashfn;
-
- ohash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- ohash_attr.base.next = &log_attr;
- ohash_attr.hash.fn = old_hash;
-
- incompat_hash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- incompat_hash_attr.base.next = &log_attr;
- incompat_hash_attr.hash.fn = tdb1_incompatible_hash;
-
- dumbhash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- dumbhash_attr.base.next = &log_attr;
- dumbhash_attr.hash.fn = tdb1_dumb_hash;
-
- plan_tests(42 * 2);
-
- for (flags = 0; flags <= TDB_CONVERT; flags += TDB_CONVERT) {
- unsigned int rwmagic = TDB1_HASH_RWLOCK_MAGIC;
-
- if (flags & TDB_CONVERT)
- tdb1_convert(&rwmagic, sizeof(rwmagic));
-
- /* Create an old-style hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", flags|TDB_VERSION1,
- O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- d = tdb_mkdata("Hello", strlen("Hello"));
- ok1(tdb_store(tdb, d, d, TDB_INSERT) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* Should not have marked rwlocks field. */
- ok1(hdr_rwlocks("run-incompatible.tdb1") == 0);
-
- /* We can still open any old-style with incompat hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1",
- TDB_VERSION1,
- O_RDWR, 0600, &incompat_hash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_fetch(tdb, d, &d) == TDB_SUCCESS);
- ok1(d.dsize == 5);
- free(d.dptr);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-le-hash.tdb1",
- TDB_VERSION1, O_RDONLY, 0, &jhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-be-hash.tdb1",
- TDB_VERSION1, O_RDONLY, 0, &jhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* OK, now create with incompatible hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1",
- flags|TDB_VERSION1,
- O_CREAT|O_RDWR|O_TRUNC, 0600,
- &incompat_hash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- d = tdb_mkdata("Hello", strlen("Hello"));
- ok1(tdb_store(tdb, d, d, TDB_INSERT) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* Should have marked rwlocks field. */
- ok1(hdr_rwlocks("run-incompatible.tdb1") == rwmagic);
-
- /* Cannot open with old hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
- O_RDWR, 0600, &ohash_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- /* Can open with jenkins hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
- O_RDWR, 0600, &jhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_fetch(tdb, d, &d) == TDB_SUCCESS);
- ok1(d.dsize == 5);
- free(d.dptr);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* Can open by letting it figure it out itself. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1,
- O_RDWR, 0600, &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- d = tdb_mkdata("Hello", strlen("Hello"));
- ok1(tdb_fetch(tdb, d, &d) == TDB_SUCCESS);
- ok1(d.dsize == 5);
- free(d.dptr);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* FIXME: Not possible with TDB2 :( */
- /* We can also use incompatible hash with other hashes. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1",
- flags|TDB_VERSION1,
- O_CREAT|O_RDWR|O_TRUNC, 0600, &dumbhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- d = tdb_mkdata("Hello", strlen("Hello"));
- ok1(tdb_store(tdb, d, d, TDB_INSERT) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* FIXME: Should have marked rwlocks field. */
- ok1(hdr_rwlocks("run-incompatible.tdb1") != rwmagic);
-
- /* It should not open if we don't specify. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1, O_RDWR, 0,
- &log_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- /* Should reopen with correct hash. */
- log_count = 0;
- tdb = tdb_open("run-incompatible.tdb1", TDB_VERSION1, O_RDWR, 0,
- &dumbhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_fetch(tdb, d, &d) == TDB_SUCCESS);
- ok1(d.dsize == 5);
- free(d.dptr);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
- }
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include <stdbool.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(30);
- key = tdb_mkdata("hi", strlen("hi"));
-
- tdb = tdb_open("run-nested-transactions.tdb1",
- TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
- ok1(tdb);
-
- /* No nesting by default. */
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- data = tdb_mkdata("world", strlen("world"));
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
- ok1(tdb_transaction_start(tdb) == TDB_ERR_EINVAL);
- ok1(tap_log_messages == 1);
-
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
- tdb_close(tdb);
-
- tdb = tdb_open("run-nested-transactions.tdb1",
- TDB_ALLOW_NESTING, O_RDWR, 0, &tap_log_attr);
- ok1(tdb);
-
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
- ok1(!tdb_exists(tdb, key));
- tdb_transaction_cancel(tdb);
- ok1(tap_log_messages == 1);
- /* Surprise! Kills inner "committed" transaction. */
- ok1(tdb_exists(tdb, key));
-
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
- ok1(!tdb_exists(tdb, key));
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
- ok1(!tdb_exists(tdb, key));
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb1-lock-tracking.h"
-#define fcntl fcntl_with_lockcheck1
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#undef fcntl
-#include <stdlib.h>
-#include <stdbool.h>
-#include "tdb1-external-agent.h"
-#include "logging.h"
-
-static struct agent *agent;
-
-static bool correct_key(TDB_DATA key)
-{
- return key.dsize == strlen("hi")
- && memcmp(key.dptr, "hi", key.dsize) == 0;
-}
-
-static bool correct_data(TDB_DATA data)
-{
- return data.dsize == strlen("world")
- && memcmp(data.dptr, "world", data.dsize) == 0;
-}
-
-static int traverse2(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *p)
-{
- ok1(correct_key(key));
- ok1(correct_data(data));
- return 0;
-}
-
-static int traverse1(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *p)
-{
- ok1(correct_key(key));
- ok1(correct_data(data));
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == WOULD_HAVE_BLOCKED);
- tdb_traverse(tdb, traverse2, NULL);
-
- /* That should *not* release the transaction lock! */
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == WOULD_HAVE_BLOCKED);
- return 0;
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(17);
- agent = prepare_external_agent1();
- if (!agent)
- err(1, "preparing agent");
-
- tdb = tdb_open("run-nested-traverse.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
- ok1(tdb);
-
- ok1(external_agent_operation1(agent, OPEN, tdb->name) == SUCCESS);
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == SUCCESS);
- ok1(external_agent_operation1(agent, TRANSACTION_COMMIT, tdb->name)
- == SUCCESS);
-
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- tdb_traverse(tdb, traverse1, NULL);
- tdb_add_flag(tdb, TDB_RDONLY);
- tdb_traverse(tdb, traverse1, NULL);
- tdb_remove_flag(tdb, TDB_RDONLY);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "private.h"
-#include <unistd.h>
-#include "tdb1-lock-tracking.h"
-
-#define fcntl fcntl_with_lockcheck1
-
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-#undef fcntl
-
-#define NUM_ENTRIES 10
-
-static bool prepare_entries(struct tdb_context *tdb)
-{
- unsigned int i;
- TDB_DATA key, data;
-
- for (i = 0; i < NUM_ENTRIES; i++) {
- key.dsize = sizeof(i);
- key.dptr = (void *)&i;
- data = tdb_mkdata("world", strlen("world"));
-
- if (tdb_store(tdb, key, data, 0) != TDB_SUCCESS)
- return false;
- }
- return true;
-}
-
-static void delete_entries(struct tdb_context *tdb)
-{
- unsigned int i;
- TDB_DATA key;
-
- for (i = 0; i < NUM_ENTRIES; i++) {
- key.dsize = sizeof(i);
- key.dptr = (void *)&i;
-
- ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
- }
-}
-
-/* We don't know how many times this will run. */
-static int delete_other(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *private_data)
-{
- unsigned int i;
- memcpy(&i, key.dptr, 4);
- i = (i + 1) % NUM_ENTRIES;
- key.dptr = (void *)&i;
- if (tdb_delete(tdb, key) != TDB_SUCCESS)
- (*(int *)private_data)++;
- return 0;
-}
-
-static int delete_self(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *private_data)
-{
- ok1(tdb_delete(tdb, key) == TDB_SUCCESS);
- return 0;
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- int errors = 0;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(40);
- tdb = tdb_open("run-no-lock-during-traverse.tdb1",
- TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &hsize);
-
- ok1(tdb);
- ok1(prepare_entries(tdb));
- ok1(locking_errors1 == 0);
- ok1(tdb_lockall(tdb) == 0);
- ok1(locking_errors1 == 0);
- ok1(tdb_traverse(tdb, delete_other, &errors) >= 0);
- ok1(errors == 0);
- ok1(locking_errors1 == 0);
- tdb_unlockall(tdb);
-
- ok1(prepare_entries(tdb));
- ok1(locking_errors1 == 0);
- ok1(tdb_lockall(tdb) == 0);
- ok1(locking_errors1 == 0);
- ok1(tdb_traverse(tdb, delete_self, NULL) == NUM_ENTRIES);
- ok1(locking_errors1 == 0);
- tdb_unlockall(tdb);
-
- ok1(prepare_entries(tdb));
- ok1(locking_errors1 == 0);
- ok1(tdb_lockall(tdb) == 0);
- ok1(locking_errors1 == 0);
- delete_entries(tdb);
- ok1(locking_errors1 == 0);
- tdb_unlockall(tdb);
-
- ok1(tdb_close(tdb) == 0);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- union tdb_attribute incompat_hash_attr;
-
- incompat_hash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- incompat_hash_attr.base.next = &tap_log_attr;
- incompat_hash_attr.hash.fn = tdb1_incompatible_hash;
-
- plan_tests(8);
-
- /* Old format (with zeroes in the hash magic fields) should
- * open with any hash (since we don't know what hash they used). */
- tdb = tdb_open("test/old-nohash-le.tdb1", TDB_VERSION1, O_RDWR, 0,
- &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("test/old-nohash-be.tdb1", TDB_VERSION1, O_RDWR, 0,
- &tap_log_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("test/old-nohash-le.tdb1", TDB_VERSION1, O_RDWR, 0,
- &incompat_hash_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- tdb = tdb_open("test/old-nohash-be.tdb1", TDB_VERSION1, O_RDWR, 0,
- &incompat_hash_attr);
- ok1(tdb);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-/* We should be able to tdb_check a O_RDONLY tdb, and we were previously allowed
- * to tdb_check() inside a transaction (though that's paranoia!). */
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(10);
- tdb = tdb_open("run-readonly-check.tdb1",
- TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- ok1(tdb);
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
-
- /* We are also allowed to do a check inside a transaction. */
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- ok1(tdb_close(tdb) == 0);
-
- tdb = tdb_open("run-readonly-check.tdb1",
- TDB_DEFAULT, O_RDONLY, 0, &tap_log_attr);
-
- ok1(tdb);
- ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_ERR_RDONLY);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- ok1(tdb_close(tdb) == 0);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-
-static void log_fn(struct tdb_context *tdb, enum tdb_log_level level,
- enum TDB_ERROR ecode, const char *message, void *priv)
-{
- unsigned int *count = priv;
- if (strstr(message, "spinlocks"))
- (*count)++;
-}
-
-/* The code should barf on TDBs created with rwlocks. */
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- unsigned int log_count;
- union tdb_attribute log_attr;
-
- log_attr.base.attr = TDB_ATTRIBUTE_LOG;
- log_attr.base.next = NULL;
- log_attr.log.fn = log_fn;
- log_attr.log.data = &log_count;
-
- plan_tests(4);
-
- /* We should fail to open rwlock-using tdbs of either endian. */
- log_count = 0;
- tdb = tdb_open("test/rwlock-le.tdb1", TDB_VERSION1, O_RDWR, 0,
- &log_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- log_count = 0;
- tdb = tdb_open("test/rwlock-be.tdb1", TDB_VERSION1, O_RDWR, 0,
- &log_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- unsigned int i;
- struct tdb1_header hdr;
- struct tdb_data key = { (unsigned char *)&hdr, sizeof(hdr) };
- struct tdb_data data = { (unsigned char *)&hdr, sizeof(hdr) };
- int flags[] = { TDB_DEFAULT, TDB_NOMMAP,
- TDB_CONVERT, TDB_NOMMAP|TDB_CONVERT };
-
- plan_tests(sizeof(flags) / sizeof(flags[0]) * 7);
- for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
- tdb = tdb_open("run-tdb1-seqnum-wrap.tdb1",
- flags[i]|TDB_VERSION1|TDB_SEQNUM,
- O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
- ok1(tdb);
- if (!tdb)
- break;
- ok1(pread(tdb->file->fd, &hdr, sizeof(hdr), 0) == sizeof(hdr));
- hdr.sequence_number = 0xFFFFFFFF;
- ok1(pwrite(tdb->file->fd, &hdr, sizeof(hdr), 0) == sizeof(hdr));
-
- /* Must not be negative: that would mean an error! */
- ok1(tdb_get_seqnum(tdb) == 0xFFFFFFFF);
-
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_get_seqnum(tdb) == 0);
- tdb_close(tdb);
- ok1(tap_log_messages == 0);
- }
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-
-int main(int argc, char *argv[])
-{
- unsigned int i, j;
- struct tdb_context *tdb;
- int flags[] = { TDB_INTERNAL, TDB_DEFAULT, TDB_NOMMAP,
- TDB_INTERNAL|TDB_CONVERT, TDB_CONVERT,
- TDB_NOMMAP|TDB_CONVERT };
- TDB_DATA key = { (unsigned char *)&j, sizeof(j) };
- TDB_DATA data = { (unsigned char *)&j, sizeof(j) };
- char *summary;
-
- plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);
- for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
- tdb = tdb_open("run-summary.tdb1", flags[i]|TDB_VERSION1,
- O_RDWR|O_CREAT|O_TRUNC, 0600, NULL);
- ok1(tdb);
- if (!tdb)
- continue;
-
- /* Put some stuff in there. */
- for (j = 0; j < 500; j++) {
- /* Make sure padding varies to we get some graphs! */
- data.dsize = j % (sizeof(j) + 1);
- if (tdb_store(tdb, key, data, TDB_REPLACE)
- != TDB_SUCCESS) {
- fail("Storing in tdb");
- }
- }
-
- summary = tdb1_summary(tdb);
- diag("%s", summary);
- ok1(strstr(summary, "Size of file/data: "));
- ok1(strstr(summary, "Number of records: 500\n"));
- ok1(strstr(summary, "Smallest/average/largest keys: 4/4/4\n"));
- ok1(strstr(summary, "Smallest/average/largest data: 0/2/4\n"));
- ok1(strstr(summary, "Smallest/average/largest padding: "));
- ok1(strstr(summary, "Number of dead records: 0\n"));
- ok1(strstr(summary, "Number of free records: 1\n"));
- ok1(strstr(summary, "Smallest/average/largest free records: "));
- ok1(strstr(summary, "Number of hash chains: 131\n"));
- ok1(strstr(summary, "Smallest/average/largest hash chains: "));
- ok1(strstr(summary, "Number of uncoalesced records: 0\n"));
- ok1(strstr(summary, "Smallest/average/largest uncoalesced runs: 0/0/0\n"));
- ok1(strstr(summary, "Percentage keys/data/padding/free/dead/rechdrs&tailers/hashes: "));
-
- free(summary);
- tdb_close(tdb);
- }
-
- return exit_status();
-}
+++ /dev/null
-#include "config.h"
-#include "tdb1-lock-tracking.h"
-#define fcntl fcntl_with_lockcheck1
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#undef fcntl_with_lockcheck
-#include <stdlib.h>
-#include <stdbool.h>
-#include "tdb1-external-agent.h"
-#include "logging.h"
-
-static struct agent *agent;
-
-static bool correct_key(TDB_DATA key)
-{
- return key.dsize == strlen("hi")
- && memcmp(key.dptr, "hi", key.dsize) == 0;
-}
-
-static bool correct_data(TDB_DATA data)
-{
- return data.dsize == strlen("world")
- && memcmp(data.dptr, "world", data.dsize) == 0;
-}
-
-static int traverse(struct tdb_context *tdb, TDB_DATA key, TDB_DATA data,
- void *p)
-{
- ok1(correct_key(key));
- ok1(correct_data(data));
- return 0;
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(13);
- agent = prepare_external_agent1();
- if (!agent)
- err(1, "preparing agent");
-
- tdb = tdb_open("run-traverse-in-transaction.tdb1",
- TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &hsize);
- ok1(tdb);
-
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
-
- ok1(external_agent_operation1(agent, OPEN, tdb->name) == SUCCESS);
-
- ok1(tdb_transaction_start(tdb) == TDB_SUCCESS);
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == WOULD_HAVE_BLOCKED);
- tdb_traverse(tdb, traverse, NULL);
-
- /* That should *not* release the transaction lock! */
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == WOULD_HAVE_BLOCKED);
- tdb_traverse(tdb, traverse, NULL);
-
- /* That should *not* release the transaction lock! */
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == WOULD_HAVE_BLOCKED);
- ok1(tdb_transaction_commit(tdb) == TDB_SUCCESS);
- /* Now we should be fine. */
- ok1(external_agent_operation1(agent, TRANSACTION_START, tdb->name)
- == SUCCESS);
-
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-
-static void log_fn(struct tdb_context *tdb, enum tdb_log_level level,
- enum TDB_ERROR ecode, const char *message, void *priv)
-{
- unsigned int *count = priv;
- if (strstr(message, "hash"))
- (*count)++;
-}
-
-static uint64_t jenkins_hashfn(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return hashlittle(key, len);
-}
-
-/* the tdb1_old_hash function is "magic" as it automatically makes us test the
- * tdb1_incompatible_hash as well, so use this wrapper. */
-static uint64_t old_hash(const void *key, size_t len, uint64_t seed,
- void *unused)
-{
- return tdb1_old_hash(key, len, seed, unused);
-}
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- unsigned int log_count;
- TDB_DATA d;
- union tdb_attribute log_attr, jhash_attr, ohash_attr,
- incompat_hash_attr;
-
- log_attr.base.attr = TDB_ATTRIBUTE_LOG;
- log_attr.base.next = NULL;
- log_attr.log.fn = log_fn;
- log_attr.log.data = &log_count;
-
- jhash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- jhash_attr.base.next = &log_attr;
- jhash_attr.hash.fn = jenkins_hashfn;
-
- ohash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- ohash_attr.base.next = &log_attr;
- ohash_attr.hash.fn = old_hash;
-
- incompat_hash_attr.base.attr = TDB_ATTRIBUTE_HASH;
- incompat_hash_attr.base.next = &log_attr;
- incompat_hash_attr.hash.fn = tdb1_incompatible_hash;
-
- plan_tests(28);
-
- /* Create with default hash. */
- log_count = 0;
- tdb = tdb_open("run-wronghash-fail.tdb1", TDB_VERSION1,
- O_CREAT|O_RDWR|O_TRUNC, 0600, &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- d = tdb_mkdata("Hello", strlen("Hello"));
- ok1(tdb_store(tdb, d, d, TDB_INSERT) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* Fail to open with different hash. */
- tdb = tdb_open("run-wronghash-fail.tdb1", TDB_VERSION1, O_RDWR, 0,
- &jhash_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- /* Create with different hash. */
- log_count = 0;
- tdb = tdb_open("run-wronghash-fail.tdb1", TDB_VERSION1,
- O_CREAT|O_RDWR|O_TRUNC, 0600, &jhash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- tdb_close(tdb);
-
- /* Endian should be no problem. */
- log_count = 0;
- tdb = tdb_open("test/jenkins-le-hash.tdb1", TDB_VERSION1, O_RDWR, 0,
- &ohash_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-be-hash.tdb1", TDB_VERSION1, O_RDWR, 0,
- &ohash_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- log_count = 0;
- /* Fail to open with old default hash. */
- tdb = tdb_open("run-wronghash-fail.tdb1", TDB_VERSION1, O_RDWR, 0,
- &ohash_attr);
- ok1(!tdb);
- ok1(log_count == 1);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-le-hash.tdb1", TDB_VERSION1, O_RDONLY,
- 0, &incompat_hash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-be-hash.tdb1", TDB_VERSION1, O_RDONLY,
- 0, &incompat_hash_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- /* It should open with jenkins hash if we don't specify. */
- log_count = 0;
- tdb = tdb_open("test/jenkins-le-hash.tdb1", TDB_VERSION1, O_RDWR, 0,
- &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- log_count = 0;
- tdb = tdb_open("test/jenkins-be-hash.tdb1", TDB_VERSION1, O_RDWR, 0,
- &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
- log_count = 0;
- tdb = tdb_open("run-wronghash-fail.tdb1", TDB_VERSION1, O_RDONLY,
- 0, &log_attr);
- ok1(tdb);
- ok1(log_count == 0);
- ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
- tdb_close(tdb);
-
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(5);
- tdb = tdb_open(NULL, TDB_INTERNAL|TDB_VERSION1, O_CREAT|O_TRUNC|O_RDWR,
- 0600, &hsize);
- ok1(tdb);
-
- /* Tickle bug on appending zero length buffer to zero length buffer. */
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", 0);
-
- ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);
- ok1(tdb_append(tdb, key, data) == TDB_SUCCESS);
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == 0);
- free(data.dptr);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb2-source.h"
-#include "tap-interface.h"
-#include <stdlib.h>
-#include "logging.h"
-
-int main(int argc, char *argv[])
-{
- struct tdb_context *tdb;
- TDB_DATA key, data;
- union tdb_attribute hsize;
-
- hsize.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize.base.next = &tap_log_attr;
- hsize.tdb1_hashsize.hsize = 1024;
-
- plan_tests(9);
- tdb = tdb_open("run.tdb1", TDB_VERSION1,
- O_CREAT|O_TRUNC|O_RDWR, 0600, &hsize);
-
- ok1(tdb);
- key = tdb_mkdata("hi", strlen("hi"));
- data = tdb_mkdata("world", strlen("world"));
-
- ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_ERR_NOEXIST);
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_SUCCESS);
- ok1(tdb_store(tdb, key, data, TDB_INSERT) == TDB_ERR_EXISTS);
- ok1(tdb_store(tdb, key, data, TDB_MODIFY) == TDB_SUCCESS);
-
- ok1(tdb_fetch(tdb, key, &data) == TDB_SUCCESS);
- ok1(data.dsize == strlen("world"));
- ok1(memcmp(data.dptr, "world", strlen("world")) == 0);
- free(data.dptr);
-
- key.dsize++;
- ok1(tdb_fetch(tdb, key, &data) == TDB_ERR_NOEXIST);
- tdb_close(tdb);
-
- return exit_status();
-}
+++ /dev/null
-#include "tdb1-external-agent.h"
-#include "tdb1-lock-tracking.h"
-#include "logging.h"
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <string.h>
-#include <errno.h>
-#include "tdb1_private.h"
-#include "tap-interface.h"
-#include <stdio.h>
-#include <stdarg.h>
-
-static struct tdb_context *tdb;
-
-static enum agent_return do_operation(enum operation op, const char *name)
-{
- TDB_DATA k;
- enum agent_return ret;
- TDB_DATA data;
-
- if (op != OPEN && !tdb) {
- diag("external: No tdb open!");
- return OTHER_FAILURE;
- }
-
- k = tdb_mkdata(name, strlen(name));
-
- locking_would_block1 = 0;
- switch (op) {
- case OPEN:
- if (tdb) {
- diag("Already have tdb %s open", tdb->name);
- return OTHER_FAILURE;
- }
- tdb = tdb_open(name, TDB_VERSION1, O_RDWR, 0, &tap_log_attr);
- if (!tdb) {
- if (!locking_would_block1)
- diag("Opening tdb gave %s", strerror(errno));
- ret = OTHER_FAILURE;
- } else
- ret = SUCCESS;
- break;
- case TRANSACTION_START:
- ret = tdb_transaction_start(tdb) == TDB_SUCCESS ? SUCCESS : OTHER_FAILURE;
- break;
- case FETCH:
- if (tdb_fetch(tdb, k, &data) != TDB_SUCCESS) {
- if (tdb->last_error == TDB_ERR_NOEXIST)
- ret = FAILED;
- else
- ret = OTHER_FAILURE;
- } else if (data.dsize != k.dsize
- || memcmp(data.dptr, k.dptr, k.dsize) != 0) {
- ret = OTHER_FAILURE;
- } else {
- ret = SUCCESS;
- }
- free(data.dptr);
- break;
- case STORE:
- if (tdb_store(tdb, k, k, 0) == TDB_SUCCESS)
- ret = SUCCESS;
- else
- ret = OTHER_FAILURE;
- break;
- case TRANSACTION_COMMIT:
- ret = tdb_transaction_commit(tdb) == TDB_SUCCESS ? SUCCESS : OTHER_FAILURE;
- break;
- case CHECK:
- ret = tdb_check(tdb, NULL, NULL) == TDB_SUCCESS ? SUCCESS : OTHER_FAILURE;
- break;
- case NEEDS_RECOVERY:
- ret = external_agent_needs_rec(tdb);
- break;
- case CLOSE:
- ret = tdb_close(tdb) == 0 ? SUCCESS : OTHER_FAILURE;
- tdb = NULL;
- break;
- default:
- ret = OTHER_FAILURE;
- }
-
- if (locking_would_block1)
- ret = WOULD_HAVE_BLOCKED;
-
- return ret;
-}
-
-struct agent {
- int cmdfd, responsefd;
-};
-
-/* Do this before doing any tdb stuff. Return handle, or NULL. */
-struct agent *prepare_external_agent1(void)
-{
- int pid, ret;
- int command[2], response[2];
- char name[1+PATH_MAX];
-
- if (pipe(command) != 0 || pipe(response) != 0)
- return NULL;
-
- pid = fork();
- if (pid < 0)
- return NULL;
-
- if (pid != 0) {
- struct agent *agent = malloc(sizeof(*agent));
-
- close(command[0]);
- close(response[1]);
- agent->cmdfd = command[1];
- agent->responsefd = response[0];
- return agent;
- }
-
- close(command[1]);
- close(response[0]);
-
- /* We want to fail, not block. */
- nonblocking_locks1 = true;
- log_prefix = "external: ";
- while ((ret = read(command[0], name, sizeof(name))) > 0) {
- enum agent_return result;
-
- result = do_operation(name[0], name+1);
- if (write(response[1], &result, sizeof(result))
- != sizeof(result))
- err(1, "Writing response");
- }
- exit(0);
-}
-
-/* Ask the external agent to try to do an operation. */
-enum agent_return external_agent_operation1(struct agent *agent,
- enum operation op,
- const char *name)
-{
- enum agent_return res;
- unsigned int len;
- char *string;
-
- if (!name)
- name = "";
- len = 1 + strlen(name) + 1;
- string = malloc(len);
-
- string[0] = op;
- strcpy(string+1, name);
-
- if (write(agent->cmdfd, string, len) != len
- || read(agent->responsefd, &res, sizeof(res)) != sizeof(res))
- res = AGENT_DIED;
-
- free(string);
- return res;
-}
-
-const char *agent_return_name1(enum agent_return ret)
-{
- return ret == SUCCESS ? "SUCCESS"
- : ret == WOULD_HAVE_BLOCKED ? "WOULD_HAVE_BLOCKED"
- : ret == AGENT_DIED ? "AGENT_DIED"
- : ret == FAILED ? "FAILED"
- : ret == OTHER_FAILURE ? "OTHER_FAILURE"
- : "**INVALID**";
-}
-
-const char *operation_name1(enum operation op)
-{
- switch (op) {
- case OPEN: return "OPEN";
- case TRANSACTION_START: return "TRANSACTION_START";
- case FETCH: return "FETCH";
- case STORE: return "STORE";
- case TRANSACTION_COMMIT: return "TRANSACTION_COMMIT";
- case CHECK: return "CHECK";
- case NEEDS_RECOVERY: return "NEEDS_RECOVERY";
- case CLOSE: return "CLOSE";
- }
- return "**INVALID**";
-}
+++ /dev/null
-#ifndef TDB_TEST_EXTERNAL_AGENT_H
-#define TDB_TEST_EXTERNAL_AGENT_H
-
-/* For locking tests, we need a different process to try things at
- * various times. */
-enum operation {
- OPEN,
- TRANSACTION_START,
- FETCH,
- STORE,
- TRANSACTION_COMMIT,
- CHECK,
- NEEDS_RECOVERY,
- CLOSE,
-};
-
-/* Do this before doing any tdb stuff. Return handle, or -1. */
-struct agent *prepare_external_agent1(void);
-
-enum agent_return {
- SUCCESS,
- WOULD_HAVE_BLOCKED,
- AGENT_DIED,
- FAILED, /* For fetch, or NEEDS_RECOVERY */
- OTHER_FAILURE,
-};
-
-/* Ask the external agent to try to do an operation.
- * name == tdb name for OPEN/OPEN_WITH_CLEAR_IF_FIRST,
- * record name for FETCH/STORE (store stores name as data too)
- */
-enum agent_return external_agent_operation1(struct agent *handle,
- enum operation op,
- const char *name);
-
-/* Mapping enum -> string. */
-const char *agent_return_name1(enum agent_return ret);
-const char *operation_name1(enum operation op);
-
-/* Internal use: */
-struct tdb_context;
-enum agent_return external_agent_needs_rec(struct tdb_context *tdb);
-#endif /* TDB_TEST_EXTERNAL_AGENT_H */
+++ /dev/null
-/* We save the locks so we can reaquire them. */
-#include "tdb1_private.h"
-#include <unistd.h>
-#include <fcntl.h>
-#include <stdarg.h>
-#include <stdlib.h>
-#include "tap-interface.h"
-#include "tdb1-lock-tracking.h"
-
-struct lock {
- struct lock *next;
- unsigned int off;
- unsigned int len;
- int type;
-};
-static struct lock *locks;
-int locking_errors1 = 0;
-bool suppress_lockcheck1 = false;
-bool nonblocking_locks1;
-int locking_would_block1 = 0;
-void (*unlock_callback1)(int fd);
-
-int fcntl_with_lockcheck1(int fd, int cmd, ... /* arg */ )
-{
- va_list ap;
- int ret, arg3;
- struct flock *fl;
- bool may_block = false;
-
- if (cmd != F_SETLK && cmd != F_SETLKW) {
- /* This may be totally bogus, but we don't know in general. */
- va_start(ap, cmd);
- arg3 = va_arg(ap, int);
- va_end(ap);
-
- return fcntl(fd, cmd, arg3);
- }
-
- va_start(ap, cmd);
- fl = va_arg(ap, struct flock *);
- va_end(ap);
-
- if (cmd == F_SETLKW && nonblocking_locks1) {
- cmd = F_SETLK;
- may_block = true;
- }
- ret = fcntl(fd, cmd, fl);
-
- /* Detect when we failed, but might have been OK if we waited. */
- if (may_block && ret == -1 && (errno == EAGAIN || errno == EACCES)) {
- locking_would_block1++;
- }
-
- if (fl->l_type == F_UNLCK) {
- struct lock **l;
- struct lock *old = NULL;
-
- for (l = &locks; *l; l = &(*l)->next) {
- if ((*l)->off == fl->l_start
- && (*l)->len == fl->l_len) {
- if (ret == 0) {
- old = *l;
- *l = (*l)->next;
- free(old);
- }
- break;
- }
- }
- if (!old && !suppress_lockcheck1) {
- diag("Unknown unlock %u@%u - %i",
- (int)fl->l_len, (int)fl->l_start, ret);
- locking_errors1++;
- }
- } else {
- struct lock *new, *i;
- unsigned int fl_end = fl->l_start + fl->l_len;
- if (fl->l_len == 0)
- fl_end = (unsigned int)-1;
-
- /* Check for overlaps: we shouldn't do this. */
- for (i = locks; i; i = i->next) {
- unsigned int i_end = i->off + i->len;
- if (i->len == 0)
- i_end = (unsigned int)-1;
-
- if (fl->l_start >= i->off && fl->l_start < i_end)
- break;
- if (fl_end >= i->off && fl_end < i_end)
- break;
-
- /* tdb_allrecord_lock does this, handle adjacent: */
- if (fl->l_start == i_end && fl->l_type == i->type) {
- if (ret == 0) {
- i->len = fl->l_len
- ? i->len + fl->l_len
- : 0;
- }
- goto done;
- }
- }
- if (i) {
- /* Special case: upgrade of allrecord lock. */
- if (i->type == F_RDLCK && fl->l_type == F_WRLCK
- && i->off == TDB1_FREELIST_TOP
- && fl->l_start == TDB1_FREELIST_TOP
- && i->len == 0
- && fl->l_len == 0) {
- if (ret == 0)
- i->type = F_WRLCK;
- goto done;
- }
- if (!suppress_lockcheck1) {
- diag("%s lock %u@%u overlaps %u@%u",
- fl->l_type == F_WRLCK ? "write" : "read",
- (int)fl->l_len, (int)fl->l_start,
- i->len, (int)i->off);
- locking_errors1++;
- }
- }
-
- if (ret == 0) {
- new = malloc(sizeof *new);
- new->off = fl->l_start;
- new->len = fl->l_len;
- new->type = fl->l_type;
- new->next = locks;
- locks = new;
- }
- }
-done:
- if (ret == 0 && fl->l_type == F_UNLCK && unlock_callback1)
- unlock_callback1(fd);
- return ret;
-}
-
-unsigned int forget_locking1(void)
-{
- unsigned int num = 0;
- while (locks) {
- struct lock *next = locks->next;
- free(locks);
- locks = next;
- num++;
- }
- return num;
-}
+++ /dev/null
-#ifndef TDB1_LOCK_TRACKING_H
-#define TDB1_LOCK_TRACKING_H
-#include "private.h"
-#include <stdbool.h>
-
-/* Set this if you want a callback after fnctl unlock. */
-extern void (*unlock_callback1)(int fd);
-
-/* Replacement fcntl. */
-int fcntl_with_lockcheck1(int fd, int cmd, ... /* arg */ );
-
-/* Discard locking info: returns number of locks outstanding. */
-unsigned int forget_locking1(void);
-
-/* Number of errors in locking. */
-extern int locking_errors1;
-
-/* Suppress lock checking. */
-extern bool suppress_lockcheck1;
-
-/* Make all locks non-blocking. */
-extern bool nonblocking_locks1;
-
-/* Number of times we failed a lock because we made it non-blocking. */
-extern int locking_would_block1;
-#endif /* LOCK_TRACKING_H */
#include "tdb.c"
#include "transaction.c"
#include "traverse.c"
-#include "tdb1_check.c"
-#include "tdb1_freelist.c"
-#include "tdb1_hash.c"
-#include "tdb1_io.c"
-#include "tdb1_lock.c"
-#include "tdb1_open.c"
-#include "tdb1_summary.c"
-#include "tdb1_tdb.c"
-#include "tdb1_transaction.c"
-#include "tdb1_traverse.c"
#include "tdb2.h"
#include "system/filesys.h"
-/* Currently we default to creating a tdb1. This will change! */
-#define TDB2_IS_DEFAULT false
-
#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif
only doing the backup if its OK
this function is also used for restore
*/
-static int backup_tdb(const char *old_name, const char *new_name,
- bool tdb2, int hash_size)
+static int backup_tdb(const char *old_name, const char *new_name)
{
struct tdb_context *tdb;
struct tdb_context *tdb_new;
struct stat st;
int count1, count2;
enum TDB_ERROR err;
- union tdb_attribute log_attr, hsize_attr;
- int tdb_flags = TDB_DEFAULT;
-
- if (!tdb2) {
- tdb_flags |= TDB_VERSION1;
- }
+ union tdb_attribute log_attr;
tmp_name = add_suffix(new_name, ".tmp");
return 1;
}
- /* create the new tdb */
- if (!tdb2 && hash_size) {
- hsize_attr.base.attr = TDB_ATTRIBUTE_TDB1_HASHSIZE;
- hsize_attr.base.next = NULL;
- hsize_attr.tdb1_hashsize.hsize = hash_size;
- log_attr.base.next = &hsize_attr;
- }
-
unlink(tmp_name);
- tdb_new = tdb_open(tmp_name, tdb_flags,
+ tdb_new = tdb_open(tmp_name, TDB_DEFAULT,
O_RDWR|O_CREAT|O_EXCL, st.st_mode & 0777,
&log_attr);
if (!tdb_new) {
/* count is < 0 means an error */
if (count < 0) {
printf("restoring %s\n", fname);
- return backup_tdb(bak_name, fname, TDB2_IS_DEFAULT, 0);
+ return backup_tdb(bak_name, fname);
}
printf("%s : %d records\n", fname, count);
static void usage(void)
{
- printf("Usage: tdbbackup [options] <fname...>\n\n");
+ printf("Usage: tdb2backup [options] <fname...>\n\n");
printf(" -h this help message\n");
- printf(" -1 make the backup a TDB1 file\n");
- printf(" -2 make the backup a TDB2 file\n");
printf(" -v verify mode (restore if corrupt)\n");
printf(" -s suffix set the backup suffix\n");
printf(" -v verify mode (restore if corrupt)\n");
- printf(" -n hashsize set the new hash size for the backup\n");
}
int ret = 0;
int c;
int verify = 0;
- int hashsize = 0;
- bool tdb2 = TDB2_IS_DEFAULT;
const char *suffix = ".bak";
- while ((c = getopt(argc, argv, "vhs:n:12")) != -1) {
+ while ((c = getopt(argc, argv, "vhs:")) != -1) {
switch (c) {
case 'h':
usage();
case 'v':
verify = 1;
break;
- case '1':
- tdb2 = false;
- break;
- case '2':
- tdb2 = true;
- break;
case 's':
suffix = optarg;
break;
- case 'n':
- hashsize = atoi(optarg);
- break;
}
}
}
} else {
if (file_newer(fname, bak_name) &&
- backup_tdb(fname, bak_name, tdb2, hashsize) != 0) {
+ backup_tdb(fname, bak_name) != 0) {
ret = 1;
}
}
#include <sys/wait.h>
#endif
-/* Currently we default to creating a tdb1. This will change! */
-#define TDB2_IS_DEFAULT false
-
//#define REOPEN_PROB 30
#define DELETE_PROB 8
#define STORE_PROB 4
static void usage(void)
{
- printf("Usage: tdbtorture"
+ printf("Usage: tdb2torture"
#if TRANSACTION_PROB
" [-t]"
#endif
int kill_random = 0;
int *done;
int tdb_flags = TDB_DEFAULT;
- bool tdb2 = TDB2_IS_DEFAULT;
char *test_tdb;
log_attr.base.attr = TDB_ATTRIBUTE_LOG;
seed_attr.base.attr = TDB_ATTRIBUTE_SEED;
seed_attr.base.next = NULL;
- while ((c = getopt(argc, argv, "n:l:s:thkS12")) != -1) {
+ while ((c = getopt(argc, argv, "n:l:s:thkS")) != -1) {
switch (c) {
case 'n':
num_procs = strtol(optarg, NULL, 0);
case 'k':
kill_random = 1;
break;
- case '1':
- tdb2 = false;
- break;
- case '2':
- tdb2 = true;
- break;
default:
usage();
}
}
- if (!tdb2) {
- tdb_flags |= TDB_VERSION1;
- /* TDB1 tdbs don't use seed. */
- log_attr.base.next = NULL;
- }
-
- test_tdb = test_path("torture.tdb");
+ test_tdb = test_path("torture.tdb2");
unlink(test_tdb);
{
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_transaction_start(tdb) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
tdb->stats.transactions++;
/* some sanity checks */
if (tdb->flags & TDB_INTERNAL) {
*/
_PUBLIC_ void tdb_transaction_cancel(struct tdb_context *tdb)
{
- if (tdb->flags & TDB_VERSION1) {
- tdb1_transaction_cancel(tdb);
- return;
- }
tdb->stats.transaction_cancel++;
_tdb_transaction_cancel(tdb);
}
*/
_PUBLIC_ enum TDB_ERROR tdb_transaction_prepare_commit(struct tdb_context *tdb)
{
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_transaction_prepare_commit(tdb) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
return tdb->last_error = _tdb_transaction_prepare_commit(tdb);
}
int i;
enum TDB_ERROR ecode;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_transaction_commit(tdb) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
if (tdb->tdb2.transaction == NULL) {
return tdb->last_error = tdb_logerr(tdb, TDB_ERR_EINVAL,
TDB_LOG_USE_ERROR,
struct tdb_data k, d;
int64_t count = 0;
- if (tdb->flags & TDB_VERSION1) {
- count = tdb1_traverse(tdb, fn, p);
- if (count == -1)
- return TDB_ERR_TO_OFF(tdb->last_error);
- return count;
- }
-
k.dptr = NULL;
for (ecode = first_in_hash(tdb, &tinfo, &k, &d.dsize);
ecode == TDB_SUCCESS;
{
struct traverse_info tinfo;
- if (tdb->flags & TDB_VERSION1) {
- tdb->last_error = TDB_SUCCESS;
- *key = tdb1_firstkey(tdb);
- /* TDB1 didn't set error for last key. */
- if (!key->dptr && tdb->last_error == TDB_SUCCESS) {
- tdb->last_error = TDB_ERR_NOEXIST;
- }
- return tdb->last_error;
- }
-
return tdb->last_error = first_in_hash(tdb, &tinfo, key, NULL);
}
struct hash_info h;
struct tdb_used_record rec;
- if (tdb->flags & TDB_VERSION1) {
- struct tdb_data last_key = *key;
- tdb->last_error = TDB_SUCCESS;
- *key = tdb1_nextkey(tdb, last_key);
- free(last_key.dptr);
- /* TDB1 didn't set error for last key. */
- if (!key->dptr && tdb->last_error == TDB_SUCCESS) {
- tdb->last_error = TDB_ERR_NOEXIST;
- }
- return tdb->last_error;
- }
-
tinfo.prev = find_and_lock(tdb, *key, F_RDLCK, &h, &rec, &tinfo);
free(key->dptr);
if (TDB_OFF_IS_ERR(tinfo.prev)) {
enum TDB_ERROR ecode;
int64_t count;
- if (tdb->flags & TDB_VERSION1) {
- if (tdb1_wipe_all(tdb) == -1)
- return tdb->last_error;
- return TDB_SUCCESS;
- }
-
ecode = tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false);
if (ecode != TDB_SUCCESS)
return tdb->last_error = ecode;
#!/usr/bin/env python
APPNAME = 'tdb'
-VERSION = '2.0.0'
+VERSION = '2.0.1'
blddir = 'bin'
'test/run-lockall.c',
'test/run-remap-in-read_traverse.c',
'test/run-seed.c',
- 'test/run-tdb1-3G-file.c',
- 'test/run-tdb1-bad-tdb-header.c',
- 'test/run-tdb1.c',
- 'test/run-tdb1-check.c',
- 'test/run-tdb1-corrupt.c',
- 'test/run-tdb1-endian.c',
- 'test/run-tdb1-hashsize.c',
- 'test/run-tdb1-incompatible.c',
- 'test/run-tdb1-nested-transactions.c',
- 'test/run-tdb1-nested-traverse.c',
- 'test/run-tdb1-no-lock-during-traverse.c',
- 'test/run-tdb1-oldhash.c',
- 'test/run-tdb1-readonly-check.c',
- 'test/run-tdb1-rwlock-check.c',
- 'test/run-tdb1-seqnum-wrap.c',
- 'test/run-tdb1-summary.c',
- 'test/run-tdb1-traverse-in-transaction.c',
- 'test/run-tdb1-wronghash-fail.c',
- 'test/run-tdb1-zero-append.c',
'test/run-tdb_errorstr.c',
'test/run-tdb_foreach.c',
'test/run-traverse.c']
'test/api-open-multiple-times.c',
'test/api-record-expand.c',
'test/api-simple-delete.c',
- 'test/api-summary.c',
- 'test/api-tdb1-flag-removal.c']
+ 'test/api-summary.c']
conf.env.TEST_API_HELPER_SRC=['test/helpapi-external-agent.c']
conf.env.TEST_RUN_HELPER_SRC=['test/helprun-external-agent.c',
'test/helprun-layout.c']
'test/failtest_helper.c',
'test/lock-tracking.c',
'test/logging.c',
- 'test/tap-interface.c',
- 'test/tdb1-external-agent.c',
- 'test/tdb1-lock-tracking.c']
+ 'test/tap-interface.c']
if Options.options.BUILD_TDB2:
conf.DEFINE('BUILD_TDB2', 1)
private_library = True
SRC = '''check.c free.c hash.c io.c lock.c open.c
- summary.c tdb.c transaction.c traverse.c
- tdb1_check.c tdb1_freelist.c tdb1_hash.c
- tdb1_io.c tdb1_lock.c tdb1_open.c
- tdb1_summary.c tdb1_tdb.c tdb1_transaction.c
- tdb1_traverse.c'''
+ summary.c tdb.c transaction.c traverse.c'''
if not bld.CONFIG_SET('USING_SYSTEM_TDB2'):
bld.SAMBA_LIBRARY('tdb',
deps='replace ccan',
includes='.',
abi_directory='ABI',
- abi_match='tdb_* tdb1_incompatible_hash',
+ abi_match='tdb_*',
hide_symbols=True,
vnum=VERSION,
public_headers='tdb2.h',
git.samba.org / ddiss / samba.git / commitdiff