if necessary
note that "len" is the minimum length needed for the db
*/
-static int tdb1_oob(struct tdb1_context *tdb, tdb1_off_t len, int probe)
+static int tdb1_oob(struct tdb_context *tdb, tdb1_off_t off, tdb1_len_t len,
+ int probe)
{
struct stat st;
- if (len <= tdb->file->map_size)
+ if (len + off < len) {
+ if (!probe) {
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_oob off %d len %d wrap\n",
+ (int)off, (int)len);
+ }
+ return -1;
+ }
+
+ if (off + 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);
+ "tdb1_oob len %d beyond internal malloc size %u",
+ (int)(off + len), (int)tdb->file->map_size);
}
return -1;
}
return -1;
}
- if (st.st_size < (size_t)len) {
+ if (st.st_size < (size_t)off + 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);
+ "tdb1_oob len %u beyond eof at %u",
+ (int)(off + len), (int)st.st_size);
}
return -1;
}
+ /* Beware >4G files! */
+ if ((tdb1_off_t)st.st_size != st.st_size) {
+ tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb1_oob len %llu too large!\n",
+ (long long)st.st_size);
+ return -1;
+ }
+
/* Unmap, update size, remap */
if (tdb1_munmap(tdb) == -1) {
tdb->last_error = TDB_ERR_IO;
}
/* write a lump of data at a specified offset */
-static int tdb1_write(struct tdb1_context *tdb, tdb1_off_t off,
+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->traverse_read) {
+ if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
- if (tdb->methods->tdb1_oob(tdb, off + len, 0) != 0)
+ if (tdb->tdb1.io->tdb1_oob(tdb, off, len, 0) != 0)
return -1;
if (tdb->file->map_ptr) {
/* read a lump of data at a specified offset, maybe convert */
-static int tdb1_read(struct tdb1_context *tdb, tdb1_off_t off, void *buf,
+static int tdb1_read(struct tdb_context *tdb, tdb1_off_t off, void *buf,
tdb1_len_t len, int cv)
{
- if (tdb->methods->tdb1_oob(tdb, off + len, 0) != 0) {
+ if (tdb->tdb1.io->tdb1_oob(tdb, off, len, 0) != 0) {
return -1;
}
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 tdb1_context *tdb, uint32_t *chain)
+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->header.hash_size;h++) {
+ 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->header.hash_size;h++) {
+ for (;h < tdb->tdb1.header.hash_size;h++) {
if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(h), &off) != 0 || off != 0) {
break;
}
}
-int tdb1_munmap(struct tdb1_context *tdb)
+int tdb1_munmap(struct tdb_context *tdb)
{
if (tdb->flags & TDB_INTERNAL)
return 0;
return 0;
}
-void tdb1_mmap(struct tdb1_context *tdb)
+void tdb1_mmap(struct tdb_context *tdb)
{
if (tdb->flags & TDB_INTERNAL)
return;
/* 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 tdb1_context *tdb, tdb1_off_t size, tdb1_off_t addition)
+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->traverse_read) {
+ if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
tdb->last_error = TDB_ERR_RDONLY;
return -1;
}
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 tdb1_context *tdb, tdb1_off_t size)
+/* You need 'size', this tells you how much you should expand by. */
+tdb1_off_t tdb1_expand_adjust(tdb1_off_t map_size, tdb1_off_t size, int page_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->methods->tdb1_oob(tdb, tdb->file->map_size + 1, 1);
+ tdb1_off_t new_size, top_size;
/* 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;
+ top_size = map_size + size * 2;
} else {
- top_size = tdb->file->map_size + size * 100;
+ top_size = 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;
+ if (map_size > 100 * 1024 * 1024) {
+ new_size = map_size * 1.10;
} else {
- map_size = tdb->file->map_size * 1.25;
+ new_size = 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->page_size) - tdb->file->map_size;
+ new_size = MAX(top_size, new_size);
+ return TDB1_ALIGN(new_size, page_size) - map_size;
+}
+
+/* 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;
+
+ 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);
+
+ size = tdb1_expand_adjust(tdb->file->map_size, size,
+ tdb->tdb1.page_size);
if (!(tdb->flags & TDB_INTERNAL))
tdb1_munmap(tdb);
/* expand the file itself */
if (!(tdb->flags & TDB_INTERNAL)) {
- if (tdb->methods->tdb1_expand_file(tdb, tdb->file->map_size, size) != 0)
+ if (tdb->tdb1.io->tdb1_expand_file(tdb, tdb->file->map_size, size) != 0)
goto fail;
}
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;
}
}
/* read/write a tdb1_off_t */
-int tdb1_ofs_read(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
+int tdb1_ofs_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
{
- return tdb->methods->tdb1_read(tdb, offset, (char*)d, sizeof(*d), TDB1_DOCONV());
+ return tdb->tdb1.io->tdb1_read(tdb, offset, (char*)d, sizeof(*d), TDB1_DOCONV());
}
-int tdb1_ofs_write(struct tdb1_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)
{
tdb1_off_t off = *d;
- return tdb->methods->tdb1_write(tdb, offset, TDB1_CONV(off), sizeof(*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 tdb1_context *tdb, tdb1_off_t offset, tdb1_len_t len)
+unsigned char *tdb1_alloc_read(struct tdb_context *tdb, tdb1_off_t offset, tdb1_len_t len)
{
unsigned char *buf;
len, strerror(errno));
return NULL;
}
- if (tdb->methods->tdb1_read(tdb, offset, buf, len, 0) == -1) {
+ if (tdb->tdb1.io->tdb1_read(tdb, offset, buf, len, 0) == -1) {
SAFE_FREE(buf);
return NULL;
}
}
/* Give a piece of tdb data to a parser */
-
-int tdb1_parse_data(struct tdb1_context *tdb, TDB_DATA key,
- tdb1_off_t offset, tdb1_len_t len,
- int (*parser)(TDB_DATA key, TDB_DATA data,
- void *private_data),
- void *private_data)
+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;
- int result;
+ enum TDB_ERROR result;
data.dsize = len;
- if ((tdb->transaction == NULL) && (tdb->file->map_ptr != NULL)) {
+ 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->methods->tdb1_oob(tdb, offset+len, 0) != 0) {
- return -1;
+ 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 -1;
+ return tdb->last_error;
}
result = parser(key, data, private_data);
}
/* read/write a record */
-int tdb1_rec_read(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
+int tdb1_rec_read(struct tdb_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
{
- if (tdb->methods->tdb1_read(tdb, offset, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
+ 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,
rec->magic, offset);
return -1;
}
- return tdb->methods->tdb1_oob(tdb, rec->next+sizeof(*rec), 0);
+ return tdb->tdb1.io->tdb1_oob(tdb, rec->next, sizeof(*rec), 0);
}
-int tdb1_rec_write(struct tdb1_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)
{
struct tdb1_record r = *rec;
- return tdb->methods->tdb1_write(tdb, offset, TDB1_CONV(r), sizeof(r));
+ return tdb->tdb1.io->tdb1_write(tdb, offset, TDB1_CONV(r), sizeof(r));
}
static const struct tdb1_methods io1_methods = {
/*
initialise the default methods table
*/
-void tdb1_io_init(struct tdb1_context *tdb)
+void tdb1_io_init(struct tdb_context *tdb)
+{
+ tdb->tdb1.io = &io1_methods;
+}
+
+enum TDB_ERROR tdb1_probe_length(struct tdb_context *tdb)
{
- tdb->methods = &io1_methods;
+ tdb->last_error = TDB_SUCCESS;
+ tdb->tdb1.io->tdb1_oob(tdb, tdb->file->map_size, 1, true);
+ return tdb->last_error;
}
projects / ccan / blobdiff