layout->elem[layout->num_elems++] = elem;
}
-void tdb_layout_add_freelist(struct tdb_layout *layout)
+void tdb_layout_add_freetable(struct tdb_layout *layout)
{
union tdb_layout_elem elem;
- elem.base.type = FREELIST;
+ elem.base.type = FREETABLE;
add(layout, elem);
}
void tdb_layout_add_free(struct tdb_layout *layout, tdb_len_t len,
- unsigned flist)
+ unsigned ftable)
{
union tdb_layout_elem elem;
elem.base.type = FREE;
elem.free.len = len;
- elem.free.flist_num = flist;
+ elem.free.ftable_num = ftable;
add(layout, elem);
}
+ htable->extra;
}
-static tdb_len_t freelist_len(struct tle_freelist *flist)
+static tdb_len_t freetable_len(struct tle_freetable *ftable)
{
- return sizeof(struct tdb_freelist);
+ return sizeof(struct tdb_freetable);
}
static void set_free_record(void *mem, tdb_len_t len)
/* We do all the work in add_to_freetable */
}
+static void add_zero_pad(struct tdb_used_record *u, size_t len, size_t extra)
+{
+ if (extra)
+ ((char *)(u + 1))[len] = '\0';
+}
+
static void set_data_record(void *mem, struct tdb_context *tdb,
struct tle_used *used)
{
struct tdb_used_record *u = mem;
- set_used_header(tdb, u, used->key.dsize, used->data.dsize,
- used->key.dsize + used->data.dsize + used->extra,
- tdb_hash(tdb, used->key.dptr, used->key.dsize));
+ set_header(tdb, u, TDB_USED_MAGIC, used->key.dsize, used->data.dsize,
+ used->key.dsize + used->data.dsize + used->extra,
+ tdb_hash(tdb, used->key.dptr, used->key.dsize));
memcpy(u + 1, used->key.dptr, used->key.dsize);
memcpy((char *)(u + 1) + used->key.dsize,
used->data.dptr, used->data.dsize);
+ add_zero_pad(u, used->key.dsize + used->data.dsize, used->extra);
}
static void set_hashtable(void *mem, struct tdb_context *tdb,
struct tdb_used_record *u = mem;
tdb_len_t len = sizeof(tdb_off_t) << TDB_SUBLEVEL_HASH_BITS;
- set_used_header(tdb, u, 0, len, len + htable->extra, 0);
+ set_header(tdb, u, TDB_HTABLE_MAGIC, 0, len, len + htable->extra, 0);
memset(u + 1, 0, len);
+ add_zero_pad(u, len, htable->extra);
}
-static void set_freelist(void *mem, struct tdb_context *tdb,
- struct tle_freelist *freelist, struct tdb_header *hdr,
- tdb_off_t last_flist)
+static void set_freetable(void *mem, struct tdb_context *tdb,
+ struct tle_freetable *freetable, struct tdb_header *hdr,
+ tdb_off_t last_ftable)
{
- struct tdb_freelist *flist = mem;
- memset(flist, 0, sizeof(*flist));
- set_used_header(tdb, &flist->hdr, 0,
- sizeof(*flist) - sizeof(flist->hdr),
- sizeof(*flist) - sizeof(flist->hdr), 1);
-
- if (last_flist) {
- flist = (struct tdb_freelist *)((char *)hdr + last_flist);
- flist->next = freelist->base.off;
+ struct tdb_freetable *ftable = mem;
+ memset(ftable, 0, sizeof(*ftable));
+ set_header(tdb, &ftable->hdr, TDB_FTABLE_MAGIC, 0,
+ sizeof(*ftable) - sizeof(ftable->hdr),
+ sizeof(*ftable) - sizeof(ftable->hdr), 0);
+
+ if (last_ftable) {
+ ftable = (struct tdb_freetable *)((char *)hdr + last_ftable);
+ ftable->next = freetable->base.off;
} else {
- hdr->free_list = freelist->base.off;
+ hdr->free_table = freetable->base.off;
}
}
static void add_to_freetable(struct tdb_context *tdb,
tdb_off_t eoff,
tdb_off_t elen,
- struct tle_freelist *freelist)
+ unsigned ftable,
+ struct tle_freetable *freetable)
{
- tdb->flist_off = freelist->base.off;
+ tdb->ftable_off = freetable->base.off;
+ tdb->ftable = ftable;
add_free_record(tdb, eoff, sizeof(struct tdb_used_record) + elen);
}
abort();
}
-static struct tle_freelist *find_flist(struct tdb_layout *layout, unsigned num)
+static struct tle_freetable *find_ftable(struct tdb_layout *layout, unsigned num)
{
unsigned i;
for (i = 0; i < layout->num_elems; i++) {
- if (layout->elem[i].base.type != FREELIST)
+ if (layout->elem[i].base.type != FREETABLE)
continue;
if (num == 0)
- return &layout->elem[i].flist;
+ return &layout->elem[i].ftable;
num--;
}
abort();
struct tdb_context *tdb_layout_get(struct tdb_layout *layout)
{
unsigned int i;
- tdb_off_t off, len, last_flist;
+ tdb_off_t off, len, last_ftable;
char *mem;
struct tdb_context *tdb;
union tdb_layout_elem *e = &layout->elem[i];
e->base.off = off;
switch (e->base.type) {
- case FREELIST:
- len = freelist_len(&e->flist);
+ case FREETABLE:
+ len = freetable_len(&e->ftable);
break;
case FREE:
len = free_record_len(e->free.len);
}
mem = malloc(off);
+ /* Fill with some weird pattern. */
+ memset(mem, 0x99, off);
/* Now populate our header, cribbing from a real TDB header. */
tdb = tdb_open(NULL, TDB_INTERNAL, O_RDWR, 0, &tap_log_attr);
memcpy(mem, tdb->map_ptr, sizeof(struct tdb_header));
tdb->map_ptr = mem;
tdb->map_size = off;
- last_flist = 0;
+ last_ftable = 0;
for (i = 0; i < layout->num_elems; i++) {
union tdb_layout_elem *e = &layout->elem[i];
switch (e->base.type) {
- case FREELIST:
- set_freelist(mem + e->base.off, tdb, &e->flist,
- (struct tdb_header *)mem, last_flist);
- last_flist = e->base.off;
+ case FREETABLE:
+ set_freetable(mem + e->base.off, tdb, &e->ftable,
+ (struct tdb_header *)mem, last_ftable);
+ last_ftable = e->base.off;
break;
case FREE:
set_free_record(mem + e->base.off, e->free.len);
break;
}
}
- /* Must have a free list! */
- assert(last_flist);
+ /* Must have a free table! */
+ assert(last_ftable);
/* Now fill the free and hash tables. */
for (i = 0; i < layout->num_elems; i++) {
switch (e->base.type) {
case FREE:
add_to_freetable(tdb, e->base.off, e->free.len,
- find_flist(layout, e->free.flist_num));
+ e->free.ftable_num,
+ find_ftable(layout, e->free.ftable_num));
break;
case DATA:
add_to_hashtable(tdb, e->base.off, e->used.key);
}
}
- tdb->flist_off = find_flist(layout, 0)->base.off;
+ tdb->ftable_off = find_ftable(layout, 0)->base.off;
/* Get physical if they asked for it. */
if (layout->filename) {
return tdb;
}
+
+void tdb_layout_free(struct tdb_layout *layout)
+{
+ unsigned int i;
+
+ for (i = 0; i < layout->num_elems; i++) {
+ if (layout->elem[i].base.type == DATA) {
+ free(layout->elem[i].used.key.dptr);
+ free(layout->elem[i].used.data.dptr);
+ }
+ }
+ free(layout->elem);
+ free(layout);
+}
projects / ccan / blobdiff