static enum TDB_ERROR replace_data(struct tdb_context *tdb,
struct hash_info *h,
struct tdb_data key, struct tdb_data dbuf,
tdb_off_t old_off, tdb_len_t old_room,
bool growing)
{
tdb_off_t new_off;
enum TDB_ERROR ecode;
/* Allocate a new record. */
new_off = alloc(tdb, key.dsize, dbuf.dsize, h->h, TDB_USED_MAGIC,
growing);
if (TDB_OFF_IS_ERR(new_off)) {
return new_off;
}
/* We didn't like the existing one: remove it. */
if (old_off) {
tdb->stats.frees++;
ecode = add_free_record(tdb, old_off,
sizeof(struct tdb_used_record)
+ key.dsize + old_room,
TDB_LOCK_WAIT, true);
if (ecode == TDB_SUCCESS)
ecode = replace_in_hash(tdb, h, new_off);
} else {
ecode = add_to_hash(tdb, h, new_off);
}
if (ecode != TDB_SUCCESS) {
return ecode;
}
new_off += sizeof(struct tdb_used_record);
ecode = tdb->methods->twrite(tdb, new_off, key.dptr, key.dsize);
if (ecode != TDB_SUCCESS) {
return ecode;
}
new_off += key.dsize;
ecode = tdb->methods->twrite(tdb, new_off, dbuf.dptr, dbuf.dsize);
if (ecode != TDB_SUCCESS) {
return ecode;
}
if (tdb->flags & TDB_SEQNUM)
tdb_inc_seqnum(tdb);
return TDB_SUCCESS;
}
static enum NTDB_ERROR replace_data(struct ntdb_context *ntdb,
struct hash_info *h,
NTDB_DATA key, NTDB_DATA dbuf,
ntdb_off_t old_off, ntdb_len_t old_room,
bool growing)
{
ntdb_off_t new_off;
enum NTDB_ERROR ecode;
/* Allocate a new record. */
new_off = alloc(ntdb, key.dsize, dbuf.dsize, NTDB_USED_MAGIC, growing);
if (NTDB_OFF_IS_ERR(new_off)) {
return NTDB_OFF_TO_ERR(new_off);
}
/* We didn't like the existing one: remove it. */
if (old_off) {
ntdb->stats.frees++;
ecode = add_free_record(ntdb, old_off,
sizeof(struct ntdb_used_record)
+ key.dsize + old_room,
NTDB_LOCK_WAIT, true);
if (ecode == NTDB_SUCCESS)
ecode = replace_in_hash(ntdb, h, new_off);
} else {
ecode = add_to_hash(ntdb, h, new_off);
}
if (ecode != NTDB_SUCCESS) {
return ecode;
}
new_off += sizeof(struct ntdb_used_record);
ecode = ntdb->io->twrite(ntdb, new_off, key.dptr, key.dsize);
if (ecode != NTDB_SUCCESS) {
return ecode;
}
new_off += key.dsize;
ecode = ntdb->io->twrite(ntdb, new_off, dbuf.dptr, dbuf.dsize);
if (ecode != NTDB_SUCCESS) {
return ecode;
}
if (ntdb->flags & NTDB_SEQNUM)
ntdb_inc_seqnum(ntdb);
return NTDB_SUCCESS;
}
enum TDB_ERROR tdb_delete(struct tdb_context *tdb, struct tdb_data key)
{
tdb_off_t off;
struct tdb_used_record rec;
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);
}
if (!off) {
ecode = TDB_ERR_NOEXIST;
goto unlock;
}
ecode = delete_from_hash(tdb, &h);
if (ecode != TDB_SUCCESS) {
goto unlock;
}
/* Free the deleted entry. */
tdb->stats.frees++;
ecode = add_free_record(tdb, off,
sizeof(struct tdb_used_record)
+ rec_key_length(&rec)
+ rec_data_length(&rec)
+ rec_extra_padding(&rec),
TDB_LOCK_WAIT, true);
if (tdb->flags & TDB_SEQNUM)
tdb_inc_seqnum(tdb);
unlock:
tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_WRLCK);
return tdb->last_error = ecode;
}
_PUBLIC_ enum NTDB_ERROR ntdb_delete(struct ntdb_context *ntdb, NTDB_DATA key)
{
ntdb_off_t off;
struct ntdb_used_record rec;
struct hash_info h;
enum NTDB_ERROR ecode;
off = find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL);
if (NTDB_OFF_IS_ERR(off)) {
return NTDB_OFF_TO_ERR(off);
}
if (!off) {
ecode = NTDB_ERR_NOEXIST;
goto unlock;
}
ecode = delete_from_hash(ntdb, &h);
if (ecode != NTDB_SUCCESS) {
goto unlock;
}
/* Free the deleted entry. */
ntdb->stats.frees++;
ecode = add_free_record(ntdb, off,
sizeof(struct ntdb_used_record)
+ rec_key_length(&rec)
+ rec_data_length(&rec)
+ rec_extra_padding(&rec),
NTDB_LOCK_WAIT, true);
if (ntdb->flags & NTDB_SEQNUM)
ntdb_inc_seqnum(ntdb);
unlock:
ntdb_unlock_hash(ntdb, h.h, F_WRLCK);
return ecode;
}
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 };
if (sizeof(off_t) <= 4) {
plan_tests(1);
pass("No 64 bit off_t");
return exit_status();
}
plan_tests(sizeof(flags) / sizeof(flags[0]) * 14);
for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
off_t old_size;
TDB_DATA k, d;
struct hash_info h;
struct tdb_used_record rec;
tdb_off_t off;
tdb = tdb_open("run-64-bit-tdb.tdb", flags[i],
O_RDWR|O_CREAT|O_TRUNC, 0600, &tap_log_attr);
ok1(tdb);
if (!tdb)
continue;
old_size = tdb->file->map_size;
/* This makes a sparse file */
ok1(ftruncate(tdb->file->fd, 0xFFFFFFF0) == 0);
ok1(add_free_record(tdb, old_size, 0xFFFFFFF0 - old_size,
TDB_LOCK_WAIT, false) == TDB_SUCCESS);
/* Now add a little record past the 4G barrier. */
ok1(tdb_expand_file(tdb, 100) == TDB_SUCCESS);
ok1(add_free_record(tdb, 0xFFFFFFF0, 100, TDB_LOCK_WAIT, false)
== TDB_SUCCESS);
ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
/* Test allocation path. */
k = tdb_mkdata("key", 4);
d = tdb_mkdata("data", 5);
ok1(tdb_store(tdb, k, d, TDB_INSERT) == 0);
ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
/* Make sure it put it at end as we expected. */
off = find_and_lock(tdb, k, F_RDLCK, &h, &rec, NULL);
ok1(off >= 0xFFFFFFF0);
tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_RDLCK);
ok1(tdb_fetch(tdb, k, &d) == 0);
ok1(d.dsize == 5);
ok1(strcmp((char *)d.dptr, "data") == 0);
free(d.dptr);
ok1(tdb_delete(tdb, k) == 0);
ok1(tdb_check(tdb, NULL, NULL) == TDB_SUCCESS);
tdb_close(tdb);
}
/* We might get messages about mmap failing, so don't test
* tap_log_messages */
return exit_status();
}
