summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
02b364a)
/* Generic record header check. */
static bool tdb_check_record(struct tdb_context *tdb,
tdb_off_t off,
/* Generic record header check. */
static bool tdb_check_record(struct tdb_context *tdb,
tdb_off_t off,
- const struct list_struct *rec)
+ const struct tdb_record *rec)
/* Check that an in-use record is valid. */
static bool tdb_check_used_record(struct tdb_context *tdb,
tdb_off_t off,
/* Check that an in-use record is valid. */
static bool tdb_check_used_record(struct tdb_context *tdb,
tdb_off_t off,
- const struct list_struct *rec,
+ const struct tdb_record *rec,
unsigned char **hashes,
int (*check)(TDB_DATA, TDB_DATA, void *),
void *private)
unsigned char **hashes,
int (*check)(TDB_DATA, TDB_DATA, void *),
void *private)
/* Check that an unused record is valid. */
static bool tdb_check_free_record(struct tdb_context *tdb,
tdb_off_t off,
/* Check that an unused record is valid. */
static bool tdb_check_free_record(struct tdb_context *tdb,
tdb_off_t off,
- const struct list_struct *rec,
+ const struct tdb_record *rec,
unsigned char **hashes)
{
if (!tdb_check_record(tdb, off, rec))
unsigned char **hashes)
{
if (!tdb_check_record(tdb, off, rec))
unsigned int h;
unsigned char **hashes;
tdb_off_t off, recovery_start;
unsigned int h;
unsigned char **hashes;
tdb_off_t off, recovery_start;
- struct list_struct rec;
bool found_recovery = false;
if (tdb_lockall(tdb) == -1)
bool found_recovery = false;
if (tdb_lockall(tdb) == -1)
static tdb_off_t tdb_dump_record(struct tdb_context *tdb, int hash,
tdb_off_t offset)
{
static tdb_off_t tdb_dump_record(struct tdb_context *tdb, int hash,
tdb_off_t offset)
{
- struct list_struct rec;
tdb_off_t tailer_ofs, tailer;
if (tdb->methods->tdb_read(tdb, offset, (char *)&rec,
tdb_off_t tailer_ofs, tailer;
if (tdb->methods->tdb_read(tdb, offset, (char *)&rec,
int ret;
long total_free = 0;
tdb_off_t offset, rec_ptr;
int ret;
long total_free = 0;
tdb_off_t offset, rec_ptr;
- struct list_struct rec;
if ((ret = tdb_lock(tdb, -1, F_WRLCK)) != 0)
return ret;
if ((ret = tdb_lock(tdb, -1, F_WRLCK)) != 0)
return ret;
#define USE_RIGHT_MERGES 0
/* read a freelist record and check for simple errors */
#define USE_RIGHT_MERGES 0
/* read a freelist record and check for simple errors */
-int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off, struct list_struct *rec)
+int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off, struct tdb_record *rec)
{
if (tdb->methods->tdb_read(tdb, off, rec, sizeof(*rec),DOCONV()) == -1)
return -1;
{
if (tdb->methods->tdb_read(tdb, off, rec, sizeof(*rec),DOCONV()) == -1)
return -1;
/* update a record tailer (must hold allocation lock) */
static int update_tailer(struct tdb_context *tdb, tdb_off_t offset,
/* update a record tailer (must hold allocation lock) */
static int update_tailer(struct tdb_context *tdb, tdb_off_t offset,
- const struct list_struct *rec)
+ const struct tdb_record *rec)
/* Add an element into the freelist. Merge adjacent records if
neccessary. */
/* Add an element into the freelist. Merge adjacent records if
neccessary. */
-int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
+int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
{
/* Allocation and tailer lock */
if (tdb_lock(tdb, -1, F_WRLCK) != 0)
{
/* Allocation and tailer lock */
if (tdb_lock(tdb, -1, F_WRLCK) != 0)
/* Look right first (I'm an Australian, dammit) */
if (offset + sizeof(*rec) + rec->rec_len + sizeof(*rec) <= tdb->map_size) {
tdb_off_t right = offset + sizeof(*rec) + rec->rec_len;
/* Look right first (I'm an Australian, dammit) */
if (offset + sizeof(*rec) + rec->rec_len + sizeof(*rec) <= tdb->map_size) {
tdb_off_t right = offset + sizeof(*rec) + rec->rec_len;
if (tdb->methods->tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: right read failed at %u\n", right));
if (tdb->methods->tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: right read failed at %u\n", right));
/* Look left */
if (offset - sizeof(tdb_off_t) > TDB_DATA_START(tdb->header.hash_size)) {
tdb_off_t left = offset - sizeof(tdb_off_t);
/* Look left */
if (offset - sizeof(tdb_off_t) > TDB_DATA_START(tdb->header.hash_size)) {
tdb_off_t left = offset - sizeof(tdb_off_t);
tdb_off_t leftsize;
/* Read in tailer and jump back to header */
tdb_off_t leftsize;
/* Read in tailer and jump back to header */
*/
static tdb_off_t tdb_allocate_ofs(struct tdb_context *tdb,
tdb_len_t length, tdb_off_t rec_ptr,
*/
static tdb_off_t tdb_allocate_ofs(struct tdb_context *tdb,
tdb_len_t length, tdb_off_t rec_ptr,
- struct list_struct *rec, tdb_off_t last_ptr)
+ struct tdb_record *rec, tdb_off_t last_ptr)
-#define MIN_REC_SIZE (sizeof(struct list_struct) + sizeof(tdb_off_t) + 8)
+#define MIN_REC_SIZE (sizeof(struct tdb_record) + sizeof(tdb_off_t) + 8)
if (rec->rec_len < length + MIN_REC_SIZE) {
/* we have to grab the whole record */
if (rec->rec_len < length + MIN_REC_SIZE) {
/* we have to grab the whole record */
}
/* allocate some space from the free list. The offset returned points
}
/* allocate some space from the free list. The offset returned points
- to a unconnected list_struct within the database with room for at
+ to a unconnected tdb_record within the database with room for at
least length bytes of total data
0 is returned if the space could not be allocated
*/
least length bytes of total data
0 is returned if the space could not be allocated
*/
-tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_struct *rec)
+tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct tdb_record *rec)
{
tdb_off_t rec_ptr, last_ptr, newrec_ptr;
struct {
{
tdb_off_t rec_ptr, last_ptr, newrec_ptr;
struct {
int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries)
{
struct tdb_context *mem_tdb = NULL;
int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries)
{
struct tdb_context *mem_tdb = NULL;
- struct list_struct rec;
tdb_off_t rec_ptr, last_ptr;
int ret = -1;
tdb_off_t rec_ptr, last_ptr;
int ret = -1;
file and doing the mmap again if necessary */
int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
{
file and doing the mmap again if necessary */
int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
{
- struct list_struct rec;
tdb_off_t offset, new_size;
if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
tdb_off_t offset, new_size;
if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
}
/* read/write a record */
}
/* read/write a record */
-int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
+int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
{
if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
return -1;
{
if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
return -1;
return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
}
return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
}
-int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
+int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
- struct list_struct r = *rec;
+ struct tdb_record r = *rec;
return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
}
return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
}
/* Returns 0 on fail. On success, return offset of record, and fills
in rec */
static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
/* Returns 0 on fail. On success, return offset of record, and fills
in rec */
static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
/* As tdb_find, but if you succeed, keep the lock */
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
/* As tdb_find, but if you succeed, keep the lock */
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
- struct list_struct *rec)
+ struct tdb_record *rec)
*/
static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
{
*/
static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
{
- struct list_struct rec;
tdb_off_t rec_ptr;
/* find entry */
tdb_off_t rec_ptr;
/* find entry */
static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
{
tdb_off_t rec_ptr;
static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
TDB_DATA ret;
uint32_t hash;
TDB_DATA ret;
uint32_t hash;
void *private_data)
{
tdb_off_t rec_ptr;
void *private_data)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
*/
static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
*/
static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
- struct list_struct rec;
if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
return 0;
if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
return 0;
}
/* actually delete an entry in the database given the offset */
}
/* actually delete an entry in the database given the offset */
-int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
+int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct tdb_record *rec)
- struct list_struct lastrec;
+ struct tdb_record lastrec;
if (tdb->read_only || tdb->traverse_read) return -1;
if (tdb->read_only || tdb->traverse_read) return -1;
{
int res = 0;
tdb_off_t rec_ptr;
{
int res = 0;
tdb_off_t rec_ptr;
- struct list_struct rec;
/* read in the hash top */
if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
/* read in the hash top */
if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
{
int res = -1;
static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
{
int res = -1;
- struct list_struct rec;
tdb_off_t rec_ptr;
if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
tdb_off_t rec_ptr;
if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
tdb_off_t rec_ptr;
static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
int ret;
if (tdb->max_dead_records != 0) {
int ret;
if (tdb->max_dead_records != 0) {
* See if we have a dead record around with enough space
*/
static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
* See if we have a dead record around with enough space
*/
static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
- struct list_struct *r, tdb_len_t length)
+ struct tdb_record *r, tdb_len_t length)
static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
TDB_DATA dbuf, int flag, uint32_t hash)
{
static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
TDB_DATA dbuf, int flag, uint32_t hash)
{
- struct list_struct rec;
tdb_off_t rec_ptr;
char *p = NULL;
int ret = -1;
tdb_off_t rec_ptr;
char *p = NULL;
int ret = -1;
*/
static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
{
*/
static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
{
- struct list_struct rec;
if (length <= sizeof(rec)) {
/* the region is not worth adding */
return 0;
if (length <= sizeof(rec)) {
/* the region is not worth adding */
return 0;
}
if (recovery_head != 0) {
}
if (recovery_head != 0) {
- struct list_struct rec;
if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
return -1;
if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
return -1;
#define CONVERT(x) (DOCONV() ? tdb_convert(&x, sizeof(x)) : &x)
#define CONVERT(x) (DOCONV() ? tdb_convert(&x, sizeof(x)) : &x)
-/* the body of the database is made of one list_struct for the free space
+/* the body of the database is made of one tdb_record for the free space
plus a separate data list for each hash value */
plus a separate data list for each hash value */
tdb_off_t next; /* offset of the next record in the list */
tdb_len_t rec_len; /* total byte length of record */
tdb_len_t key_len; /* byte length of key */
tdb_off_t next; /* offset of the next record in the list */
tdb_len_t rec_len; /* total byte length of record */
tdb_len_t key_len; /* byte length of key */
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
void *tdb_convert(void *buf, uint32_t size);
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
void *tdb_convert(void *buf, uint32_t size);
-int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec);
-tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct list_struct *rec);
+int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
+tdb_off_t tdb_allocate(struct tdb_context *tdb, tdb_len_t length, struct tdb_record *rec);
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off);
int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off);
int _tdb_transaction_cancel(struct tdb_context *tdb, int ltype);
int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d);
int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off);
int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off);
int _tdb_transaction_cancel(struct tdb_context *tdb, int ltype);
-int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec);
-int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec);
-int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec);
+int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
+int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
+int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct tdb_record *rec);
unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len);
int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
tdb_off_t offset, tdb_len_t len,
unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len);
int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
tdb_off_t offset, tdb_len_t len,
void *private_data),
void *private_data);
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
void *private_data),
void *private_data);
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
- struct list_struct *rec);
+ struct tdb_record *rec);
void tdb_io_init(struct tdb_context *tdb);
int tdb_expand(struct tdb_context *tdb, tdb_off_t size);
int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off,
void tdb_io_init(struct tdb_context *tdb);
int tdb_expand(struct tdb_context *tdb, tdb_off_t size);
int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off,
- struct list_struct *rec);
+ struct tdb_record *rec);
TDB_DATA key, orig_data, data;
uint32_t hash;
tdb_off_t rec_ptr;
TDB_DATA key, orig_data, data;
uint32_t hash;
tdb_off_t rec_ptr;
- struct list_struct rec;
plan_tests(24);
tdb = tdb_open("/tmp/test.tdb", 1024, TDB_CLEAR_IF_FIRST,
plan_tests(24);
tdb = tdb_open("/tmp/test.tdb", 1024, TDB_CLEAR_IF_FIRST,
/* From the free list chain and hash chains. */
verifiable += 3 * sizeof(tdb_off_t);
/* From the record headers & tailer */
/* From the free list chain and hash chains. */
verifiable += 3 * sizeof(tdb_off_t);
/* From the record headers & tailer */
- verifiable += 5 * (sizeof(struct list_struct) + sizeof(uint32_t));
+ verifiable += 5 * (sizeof(struct tdb_record) + sizeof(uint32_t));
/* The free block: we ignore datalen, keylen, full_hash. */
/* The free block: we ignore datalen, keylen, full_hash. */
- verifiable += sizeof(struct list_struct) - 3*sizeof(uint32_t) +
+ verifiable += sizeof(struct tdb_record) - 3*sizeof(uint32_t) +
sizeof(uint32_t);
/* Our check function verifies the key and data. */
verifiable += ksize + dsize;
sizeof(uint32_t);
/* Our check function verifies the key and data. */
verifiable += ksize + dsize;
tdb_off_t *recovery_offset,
tdb_len_t *recovery_max_size)
{
tdb_off_t *recovery_offset,
tdb_len_t *recovery_max_size)
{
- struct list_struct rec;
const struct tdb_methods *methods = tdb->transaction->io_methods;
tdb_off_t recovery_head;
const struct tdb_methods *methods = tdb->transaction->io_methods;
tdb_off_t recovery_head;
tdb_len_t recovery_size;
unsigned char *data, *p;
const struct tdb_methods *methods = tdb->transaction->io_methods;
tdb_len_t recovery_size;
unsigned char *data, *p;
const struct tdb_methods *methods = tdb->transaction->io_methods;
- struct list_struct *rec;
+ struct tdb_record *rec;
tdb_off_t recovery_offset, recovery_max_size;
tdb_off_t old_map_size = tdb->transaction->old_map_size;
uint32_t magic, tailer;
tdb_off_t recovery_offset, recovery_max_size;
tdb_off_t old_map_size = tdb->transaction->old_map_size;
uint32_t magic, tailer;
- rec = (struct list_struct *)data;
+ rec = (struct tdb_record *)data;
memset(rec, 0, sizeof(*rec));
rec->magic = 0;
memset(rec, 0, sizeof(*rec));
rec->magic = 0;
magic = TDB_RECOVERY_MAGIC;
CONVERT(magic);
magic = TDB_RECOVERY_MAGIC;
CONVERT(magic);
- *magic_offset = recovery_offset + offsetof(struct list_struct, magic);
+ *magic_offset = recovery_offset + offsetof(struct tdb_record, magic);
if (methods->tdb_write(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_setup_recovery: failed to write recovery magic\n"));
if (methods->tdb_write(tdb, *magic_offset, &magic, sizeof(magic)) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_setup_recovery: failed to write recovery magic\n"));
tdb_off_t recovery_head, recovery_eof;
unsigned char *data, *p;
uint32_t zero = 0;
tdb_off_t recovery_head, recovery_eof;
unsigned char *data, *p;
uint32_t zero = 0;
- struct list_struct rec;
/* find the recovery area */
if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
/* find the recovery area */
if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
}
/* remove the recovery magic */
}
/* remove the recovery magic */
- if (tdb_ofs_write(tdb, recovery_head + offsetof(struct list_struct, magic),
+ if (tdb_ofs_write(tdb, recovery_head + offsetof(struct tdb_record, magic),
&zero) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to remove recovery magic\n"));
tdb->ecode = TDB_ERR_IO;
&zero) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to remove recovery magic\n"));
tdb->ecode = TDB_ERR_IO;
/* Uses traverse lock: 0 = finish, TDB_NEXT_LOCK_ERR = error,
other = record offset */
static tdb_off_t tdb_next_lock(struct tdb_context *tdb, struct tdb_traverse_lock *tlock,
/* Uses traverse lock: 0 = finish, TDB_NEXT_LOCK_ERR = error,
other = record offset */
static tdb_off_t tdb_next_lock(struct tdb_context *tdb, struct tdb_traverse_lock *tlock,
- struct list_struct *rec)
+ struct tdb_record *rec)
{
int want_next = (tlock->off != 0);
{
int want_next = (tlock->off != 0);
struct tdb_traverse_lock *tl)
{
TDB_DATA key, dbuf;
struct tdb_traverse_lock *tl)
{
TDB_DATA key, dbuf;
- struct list_struct rec;
int ret = 0, count = 0;
tdb_off_t off;
int ret = 0, count = 0;
tdb_off_t off;
TDB_DATA tdb_firstkey(struct tdb_context *tdb)
{
TDB_DATA key;
TDB_DATA tdb_firstkey(struct tdb_context *tdb)
{
TDB_DATA key;
- struct list_struct rec;
tdb_off_t off;
/* release any old lock */
tdb_off_t off;
/* release any old lock */
{
uint32_t oldhash;
TDB_DATA key = tdb_null;
{
uint32_t oldhash;
TDB_DATA key = tdb_null;
- struct list_struct rec;
unsigned char *k = NULL;
tdb_off_t off;
unsigned char *k = NULL;
tdb_off_t off;