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)
+void tdb_layout_add_free(struct tdb_layout *layout, tdb_len_t len,
+ unsigned ftable)
{
union tdb_layout_elem elem;
elem.base.type = FREE;
elem.free.len = len;
+ 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_header(tdb, u, used->key.dsize, used->data.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_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)
+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_header(tdb, &flist->hdr, 0,
- sizeof(*flist) - sizeof(flist->hdr),
- sizeof(*flist) - sizeof(flist->hdr), 1);
+ 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_table = freetable->base.off;
+ }
}
static void add_to_freetable(struct tdb_context *tdb,
tdb_off_t eoff,
- tdb_off_t elen)
+ tdb_off_t elen,
+ unsigned ftable,
+ struct tle_freetable *freetable)
{
- add_free_record(tdb, eoff, sizeof(struct tdb_used_record) + elen);
+ tdb->ftable_off = freetable->base.off;
+ tdb->ftable = ftable;
+ add_free_record(tdb, eoff, sizeof(struct tdb_used_record) + elen,
+ TDB_LOCK_WAIT, false);
}
static tdb_off_t hbucket_off(tdb_off_t group_start, unsigned ingroup)
abort();
}
+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 != FREETABLE)
+ continue;
+ if (num == 0)
+ return &layout->elem[i].ftable;
+ num--;
+ }
+ abort();
+}
+
/* FIXME: Support TDB_CONVERT */
struct tdb_context *tdb_layout_get(struct tdb_layout *layout)
{
unsigned int i;
- tdb_off_t off, len, flist_off = 0;
+ 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:
- assert(flist_off == 0);
- flist_off = off;
- len = freelist_len(&e->flist);
+ case FREETABLE:
+ len = freetable_len(&e->ftable);
break;
case FREE:
len = free_record_len(e->free.len);
}
off += len;
}
- /* Must have a free list! */
- assert(flist_off);
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));
+ memcpy(mem, tdb->file->map_ptr, sizeof(struct tdb_header));
/* Mug the tdb we have to make it use this. */
- free(tdb->map_ptr);
- tdb->map_ptr = mem;
- tdb->map_size = off;
- tdb->flist_off = flist_off;
+ free(tdb->file->map_ptr);
+ tdb->file->map_ptr = mem;
+ tdb->file->map_size = off;
+ 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);
+ 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 table! */
+ assert(last_ftable);
/* Now fill the free and hash tables. */
for (i = 0; i < layout->num_elems; i++) {
union tdb_layout_elem *e = &layout->elem[i];
switch (e->base.type) {
case FREE:
- add_to_freetable(tdb, e->base.off, e->free.len);
+ add_to_freetable(tdb, e->base.off, e->free.len,
+ 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->ftable_off = find_ftable(layout, 0)->base.off;
+
/* Get physical if they asked for it. */
if (layout->filename) {
int fd = open(layout->filename, O_WRONLY|O_TRUNC|O_CREAT,
0600);
if (fd < 0)
err(1, "opening %s for writing", layout->filename);
- if (write(fd, tdb->map_ptr, tdb->map_size) != tdb->map_size)
+ if (write(fd, tdb->file->map_ptr, tdb->file->map_size)
+ != tdb->file->map_size)
err(1, "writing %s", layout->filename);
close(fd);
tdb_close(tdb);
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);
+}