void tdb_mmap(struct tdb_context *tdb)
{
+ int mmap_flags;
+
if (tdb->flags & TDB_INTERNAL)
return;
if (tdb->flags & TDB_NOMMAP)
return;
- tdb->file->map_ptr = mmap(NULL, tdb->file->map_size, tdb->mmap_flags,
- MAP_SHARED, tdb->file->fd, 0);
+ if ((tdb->open_flags & O_ACCMODE) == O_RDONLY)
+ mmap_flags = PROT_READ;
+ else
+ mmap_flags = PROT_READ | PROT_WRITE;
+
+ /* size_t can be smaller than off_t. */
+ if ((size_t)tdb->file->map_size == tdb->file->map_size) {
+ tdb->file->map_ptr = mmap(NULL, tdb->file->map_size,
+ mmap_flags,
+ MAP_SHARED, tdb->file->fd, 0);
+ } else
+ tdb->file->map_ptr = MAP_FAILED;
/*
* NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
/* check for an out of bounds access - if it is out of bounds then
see if the database has been expanded by someone else and expand
if necessary
- note that "len" is the minimum length needed for the db
+ note that "len" is the minimum length needed for the db.
+
+ If probe is true, len being too large isn't a failure.
*/
static enum TDB_ERROR tdb_oob(struct tdb_context *tdb, tdb_off_t len,
bool probe)
enum TDB_ERROR ecode;
/* We can't hold pointers during this: we could unmap! */
- assert(!tdb->direct_access
+ assert(!tdb->tdb2.direct_access
|| (tdb->flags & TDB_NOLOCK)
|| tdb_has_expansion_lock(tdb));
if (len <= tdb->file->map_size)
- return 0;
+ return TDB_SUCCESS;
if (tdb->flags & TDB_INTERNAL) {
- if (!probe) {
- tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb_oob len %lld beyond internal"
- " malloc size %lld",
- (long long)len,
- (long long)tdb->file->map_size);
- }
+ if (probe)
+ return TDB_SUCCESS;
+
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob len %lld beyond internal"
+ " malloc size %lld",
+ (long long)len,
+ (long long)tdb->file->map_size);
return TDB_ERR_IO;
}
tdb_unlock_expand(tdb, F_RDLCK);
if (st.st_size < (size_t)len) {
- if (!probe) {
- tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb_oob len %zu beyond eof at %zu",
- (size_t)len, st.st_size);
- }
+ if (probe)
+ return TDB_SUCCESS;
+
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob len %zu beyond eof at %zu",
+ (size_t)len, st.st_size);
return TDB_ERR_IO;
}
/* Endian conversion: we only ever deal with 8 byte quantities */
void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size)
{
+ assert(size % 8 == 0);
if (unlikely((tdb->flags & TDB_CONVERT)) && buf) {
uint64_t i, *p = (uint64_t *)buf;
for (i = 0; i < size / 8; i++)
val = tdb_access_read(tdb, base + start * sizeof(tdb_off_t),
(end - start) * sizeof(tdb_off_t), false);
if (TDB_PTR_IS_ERR(val)) {
- return TDB_PTR_ERR(val);
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(val));
}
for (i = 0; i < (end - start); i++) {
/* Zero vs non-zero is the same unconverted: minor optimization. */
val = tdb_access_read(tdb, off, num * sizeof(tdb_off_t), false);
if (TDB_PTR_IS_ERR(val)) {
- return TDB_PTR_ERR(val);
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(val));
}
for (i = 0; i < num; i++) {
enum TDB_ERROR zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
{
char buf[8192] = { 0 };
- void *p = tdb->methods->direct(tdb, off, len, true);
+ void *p = tdb->tdb2.io->direct(tdb, off, len, true);
enum TDB_ERROR ecode = TDB_SUCCESS;
- assert(!tdb->read_only);
+ assert(!(tdb->flags & TDB_RDONLY));
if (TDB_PTR_IS_ERR(p)) {
return TDB_PTR_ERR(p);
}
}
while (len) {
unsigned todo = len < sizeof(buf) ? len : sizeof(buf);
- ecode = tdb->methods->twrite(tdb, off, buf, todo);
+ ecode = tdb->tdb2.io->twrite(tdb, off, buf, todo);
if (ecode != TDB_SUCCESS) {
break;
}
enum TDB_ERROR ecode;
if (likely(!(tdb->flags & TDB_CONVERT))) {
- tdb_off_t *p = tdb->methods->direct(tdb, off, sizeof(*p),
+ tdb_off_t *p = tdb->tdb2.io->direct(tdb, off, sizeof(*p),
false);
if (TDB_PTR_IS_ERR(p)) {
- return TDB_PTR_ERR(p);
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(p));
}
if (p)
return *p;
ecode = tdb_read_convert(tdb, off, &ret, sizeof(ret));
if (ecode != TDB_SUCCESS) {
- return ecode;
+ return TDB_ERR_TO_OFF(ecode);
}
return ret;
}
{
enum TDB_ERROR ecode;
- if (tdb->read_only) {
+ if (tdb->flags & TDB_RDONLY) {
return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Write to read-only database");
}
- ecode = tdb->methods->oob(tdb, off + len, 0);
+ ecode = tdb->tdb2.io->oob(tdb, off + len, false);
if (ecode != TDB_SUCCESS) {
return ecode;
}
{
enum TDB_ERROR ecode;
- ecode = tdb->methods->oob(tdb, off + len, 0);
+ ecode = tdb->tdb2.io->oob(tdb, off + len, false);
if (ecode != TDB_SUCCESS) {
return ecode;
}
" %zu bytes", len);
}
memcpy(conv, rec, len);
- ecode = tdb->methods->twrite(tdb, off,
+ ecode = tdb->tdb2.io->twrite(tdb, off,
tdb_convert(tdb, conv, len), len);
free(conv);
} else {
- ecode = tdb->methods->twrite(tdb, off, rec, len);
+ ecode = tdb->tdb2.io->twrite(tdb, off, rec, len);
}
return ecode;
}
enum TDB_ERROR tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
void *rec, size_t len)
{
- enum TDB_ERROR ecode = tdb->methods->tread(tdb, off, rec, len);
+ enum TDB_ERROR ecode = tdb->tdb2.io->tread(tdb, off, rec, len);
tdb_convert(tdb, rec, len);
return ecode;
}
enum TDB_ERROR tdb_write_off(struct tdb_context *tdb,
tdb_off_t off, tdb_off_t val)
{
- if (tdb->read_only) {
+ if (tdb->flags & TDB_RDONLY) {
return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Write to read-only database");
}
if (likely(!(tdb->flags & TDB_CONVERT))) {
- tdb_off_t *p = tdb->methods->direct(tdb, off, sizeof(*p),
+ tdb_off_t *p = tdb->tdb2.io->direct(tdb, off, sizeof(*p),
true);
if (TDB_PTR_IS_ERR(p)) {
return TDB_PTR_ERR(p);
(size_t)(prefix + len));
return TDB_ERR_PTR(TDB_ERR_OOM);
} else {
- ecode = tdb->methods->tread(tdb, offset, buf+prefix, len);
+ ecode = tdb->tdb2.io->tread(tdb, offset, buf+prefix, len);
if (unlikely(ecode != TDB_SUCCESS)) {
free(buf);
return TDB_ERR_PTR(ecode);
char buf[8192];
enum TDB_ERROR ecode;
- if (tdb->read_only) {
+ if (tdb->flags & TDB_RDONLY) {
return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Expand on read-only database");
}
void *ret = NULL;
if (likely(!(tdb->flags & TDB_CONVERT))) {
- ret = tdb->methods->direct(tdb, off, len, false);
+ ret = tdb->tdb2.io->direct(tdb, off, len, false);
if (TDB_PTR_IS_ERR(ret)) {
return ret;
if (TDB_PTR_IS_ERR(hdr)) {
return hdr;
}
- hdr->next = tdb->access;
- tdb->access = hdr;
+ hdr->next = tdb->tdb2.access;
+ tdb->tdb2.access = hdr;
ret = hdr + 1;
if (convert) {
tdb_convert(tdb, (void *)ret, len);
}
} else
- tdb->direct_access++;
+ tdb->tdb2.direct_access++;
return ret;
}
{
void *ret = NULL;
- if (tdb->read_only) {
+ if (tdb->flags & TDB_RDONLY) {
tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Write to read-only database");
return TDB_ERR_PTR(TDB_ERR_RDONLY);
}
if (likely(!(tdb->flags & TDB_CONVERT))) {
- ret = tdb->methods->direct(tdb, off, len, true);
+ ret = tdb->tdb2.io->direct(tdb, off, len, true);
if (TDB_PTR_IS_ERR(ret)) {
return ret;
if (TDB_PTR_IS_ERR(hdr)) {
return hdr;
}
- hdr->next = tdb->access;
- tdb->access = hdr;
+ hdr->next = tdb->tdb2.access;
+ tdb->tdb2.access = hdr;
hdr->off = off;
hdr->len = len;
hdr->convert = convert;
if (convert)
tdb_convert(tdb, (void *)ret, len);
} else
- tdb->direct_access++;
+ tdb->tdb2.direct_access++;
return ret;
}
{
struct tdb_access_hdr **hp;
- for (hp = &tdb->access; *hp; hp = &(*hp)->next) {
+ for (hp = &tdb->tdb2.access; *hp; hp = &(*hp)->next) {
if (*hp + 1 == p)
return hp;
}
*hp = hdr->next;
free(hdr);
} else
- tdb->direct_access--;
+ tdb->tdb2.direct_access--;
}
enum TDB_ERROR tdb_access_commit(struct tdb_context *tdb, void *p)
*hp = hdr->next;
free(hdr);
} else {
- tdb->direct_access--;
+ tdb->tdb2.direct_access--;
ecode = TDB_SUCCESS;
}
if (unlikely(!tdb->file->map_ptr))
return NULL;
- ecode = tdb_oob(tdb, off + len, true);
+ ecode = tdb_oob(tdb, off + len, false);
if (unlikely(ecode != TDB_SUCCESS))
return TDB_ERR_PTR(ecode);
return (char *)tdb->file->map_ptr + off;
{
tdb_off_t seq;
+ if (tdb->flags & TDB_VERSION1) {
+ tdb1_increment_seqnum_nonblock(tdb);
+ return;
+ }
+
if (likely(!(tdb->flags & TDB_CONVERT))) {
int64_t *direct;
- direct = tdb->methods->direct(tdb,
+ direct = tdb->tdb2.io->direct(tdb,
offsetof(struct tdb_header,
seqnum),
sizeof(*direct), true);
*/
void tdb_io_init(struct tdb_context *tdb)
{
- tdb->methods = &io_methods;
+ tdb->tdb2.io = &io_methods;
}