- /*
+ /*
Unix SMB/CIFS implementation.
trivial database library
#include <assert.h>
#include <ccan/likely/likely.h>
-void tdb_munmap(struct tdb_context *tdb)
+void tdb_munmap(struct tdb_file *file)
{
- if (tdb->flags & TDB_INTERNAL)
+ if (file->fd == -1)
return;
- if (tdb->map_ptr) {
- munmap(tdb->map_ptr, tdb->map_size);
- tdb->map_ptr = NULL;
+ if (file->map_ptr) {
+ munmap(file->map_ptr, file->map_size);
+ file->map_ptr = NULL;
}
}
void tdb_mmap(struct tdb_context *tdb)
{
+ int mmap_flags;
+
if (tdb->flags & TDB_INTERNAL)
return;
if (tdb->flags & TDB_NOMMAP)
return;
- tdb->map_ptr = mmap(NULL, tdb->map_size, tdb->mmap_flags,
- MAP_SHARED, tdb->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 !!!!
*/
- if (tdb->map_ptr == MAP_FAILED) {
- tdb->map_ptr = NULL;
- tdb->log(tdb, TDB_DEBUG_WARNING, tdb->log_priv,
- "tdb_mmap failed for size %lld (%s)\n",
- (long long)tdb->map_size, strerror(errno));
+ if (tdb->file->map_ptr == MAP_FAILED) {
+ tdb->file->map_ptr = NULL;
+ tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING,
+ "tdb_mmap failed for size %lld (%s)",
+ (long long)tdb->file->map_size, strerror(errno));
}
}
/* 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
+ if necessary
+ note that "len" is the minimum length needed for the db.
+
+ If probe is true, len being too large isn't a failure.
*/
-static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe)
+static enum TDB_ERROR tdb_oob(struct tdb_context *tdb,
+ tdb_off_t off, tdb_len_t len, bool probe)
{
struct stat st;
- int ret;
+ enum TDB_ERROR ecode;
/* We can't hold pointers during this: we could unmap! */
- assert(!tdb->direct_access || tdb_has_expansion_lock(tdb));
+ assert(!tdb->tdb2.direct_access
+ || (tdb->flags & TDB_NOLOCK)
+ || tdb_has_expansion_lock(tdb));
+
+ if (len + off < len) {
+ if (probe)
+ return TDB_SUCCESS;
+
+ return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob off %llu len %llu wrap\n",
+ (long long)off, (long long)len);
+ }
- if (len <= tdb->map_size)
- return 0;
+ if (len + off <= tdb->file->map_size)
+ return TDB_SUCCESS;
if (tdb->flags & TDB_INTERNAL) {
- if (!probe) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB_ERR_IO;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "tdb_oob len %lld beyond internal"
- " malloc size %lld\n",
- (long long)len,
- (long long)tdb->map_size);
- }
- return -1;
+ 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)(off + len),
+ (long long)tdb->file->map_size);
+ return TDB_ERR_IO;
}
- if (tdb_lock_expand(tdb, F_RDLCK) != 0)
- return -1;
+ ecode = tdb_lock_expand(tdb, F_RDLCK);
+ if (ecode != TDB_SUCCESS) {
+ return ecode;
+ }
- ret = fstat(tdb->fd, &st);
+ if (fstat(tdb->file->fd, &st) != 0) {
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "Failed to fstat file: %s", strerror(errno));
+ tdb_unlock_expand(tdb, F_RDLCK);
+ return TDB_ERR_IO;
+ }
tdb_unlock_expand(tdb, F_RDLCK);
- if (ret == -1) {
- tdb->ecode = TDB_ERR_IO;
- return -1;
- }
+ if (st.st_size < off + len) {
+ if (probe)
+ return TDB_SUCCESS;
- if (st.st_size < (size_t)len) {
- if (!probe) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB_ERR_IO;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "tdb_oob len %lld beyond eof at %lld\n",
- (long long)len, (long long)st.st_size);
- }
- return -1;
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob len %llu beyond eof at %zu",
+ (long long)(off + len), st.st_size);
+ return TDB_ERR_IO;
}
/* Unmap, update size, remap */
- tdb_munmap(tdb);
+ tdb_munmap(tdb->file);
- tdb->map_size = st.st_size;
+ tdb->file->map_size = st.st_size;
tdb_mmap(tdb);
- return 0;
-}
-
-static void *tdb_direct(struct tdb_context *tdb, tdb_off_t off, size_t len)
-{
- if (unlikely(!tdb->map_ptr))
- return NULL;
-
- /* FIXME: We can do a subset of this! */
- if (tdb->transaction)
- return NULL;
-
- if (unlikely(tdb_oob(tdb, off + len, true) == -1))
- return NULL;
- return (char *)tdb->map_ptr + off;
-}
-
-/* Either make a copy into pad and return that, or return ptr into mmap. */
-/* Note: pad has to be a real object, so we can't get here if len
- * overflows size_t */
-void *tdb_get(struct tdb_context *tdb, tdb_off_t off, void *pad, size_t len)
-{
- if (likely(!(tdb->flags & TDB_CONVERT))) {
- void *ret = tdb_direct(tdb, off, len);
- if (ret)
- return ret;
- }
- return tdb_read_convert(tdb, off, pad, len) == -1 ? NULL : pad;
+ return TDB_SUCCESS;
}
/* 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++)
return buf;
}
+/* Return first non-zero offset in offset array, or end, or -ve error. */
/* FIXME: Return the off? */
uint64_t tdb_find_nonzero_off(struct tdb_context *tdb,
tdb_off_t base, uint64_t start, uint64_t end)
/* Zero vs non-zero is the same unconverted: minor optimization. */
val = tdb_access_read(tdb, base + start * sizeof(tdb_off_t),
(end - start) * sizeof(tdb_off_t), false);
- if (!val)
- return end;
+ if (TDB_PTR_IS_ERR(val)) {
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(val));
+ }
for (i = 0; i < (end - start); i++) {
if (val[i])
return start + i;
}
-/* Return first zero offset in num offset array, or num. */
+/* Return first zero offset in num offset array, or num, or -ve error. */
uint64_t tdb_find_zero_off(struct tdb_context *tdb, tdb_off_t off,
uint64_t num)
{
/* Zero vs non-zero is the same unconverted: minor optimization. */
val = tdb_access_read(tdb, off, num * sizeof(tdb_off_t), false);
- if (!val)
- return num;
+ if (TDB_PTR_IS_ERR(val)) {
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(val));
+ }
for (i = 0; i < num; i++) {
if (!val[i])
return i;
}
-int zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
+enum TDB_ERROR zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
{
char buf[8192] = { 0 };
- void *p = tdb_direct(tdb, off, len);
+ void *p = tdb->tdb2.io->direct(tdb, off, len, true);
+ enum TDB_ERROR ecode = TDB_SUCCESS;
+
+ assert(!(tdb->flags & TDB_RDONLY));
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_PTR_ERR(p);
+ }
if (p) {
memset(p, 0, len);
- return 0;
+ return ecode;
}
while (len) {
unsigned todo = len < sizeof(buf) ? len : sizeof(buf);
- if (tdb->methods->write(tdb, off, buf, todo) == -1)
- return -1;
+ ecode = tdb->tdb2.io->twrite(tdb, off, buf, todo);
+ if (ecode != TDB_SUCCESS) {
+ break;
+ }
len -= todo;
off += todo;
}
- return 0;
+ return ecode;
}
tdb_off_t tdb_read_off(struct tdb_context *tdb, tdb_off_t off)
{
- tdb_off_t pad, *ret;
+ tdb_off_t ret;
+ enum TDB_ERROR ecode;
- ret = tdb_get(tdb, off, &pad, sizeof(pad));
- if (!ret) {
- return TDB_OFF_ERR;
- }
- return *ret;
-}
-
-/* Even on files, we can get partial writes due to signals. */
-bool tdb_pwrite_all(int fd, const void *buf, size_t len, tdb_off_t off)
-{
- while (len) {
- ssize_t ret;
- ret = pwrite(fd, buf, len, off);
- if (ret < 0)
- return false;
- if (ret == 0) {
- errno = ENOSPC;
- return false;
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
+ tdb_off_t *p = tdb->tdb2.io->direct(tdb, off, sizeof(*p),
+ false);
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_ERR_TO_OFF(TDB_PTR_ERR(p));
}
- buf = (char *)buf + ret;
- off += ret;
- len -= ret;
+ if (p)
+ return *p;
}
- return true;
-}
-/* Even on files, we can get partial reads due to signals. */
-bool tdb_pread_all(int fd, void *buf, size_t len, tdb_off_t off)
-{
- while (len) {
- ssize_t ret;
- ret = pread(fd, buf, len, off);
- if (ret < 0)
- return false;
- if (ret == 0) {
- /* ETOOSHORT? */
- errno = EWOULDBLOCK;
- return false;
- }
- buf = (char *)buf + ret;
- off += ret;
- len -= ret;
+ ecode = tdb_read_convert(tdb, off, &ret, sizeof(ret));
+ if (ecode != TDB_SUCCESS) {
+ return TDB_ERR_TO_OFF(ecode);
}
- return true;
-}
-
-bool tdb_read_all(int fd, void *buf, size_t len)
-{
- while (len) {
- ssize_t ret;
- ret = read(fd, buf, len);
- if (ret < 0)
- return false;
- if (ret == 0) {
- /* ETOOSHORT? */
- errno = EWOULDBLOCK;
- return false;
- }
- buf = (char *)buf + ret;
- len -= ret;
- }
- return true;
+ return ret;
}
/* write a lump of data at a specified offset */
-static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
- const void *buf, tdb_len_t len)
+static enum TDB_ERROR tdb_write(struct tdb_context *tdb, tdb_off_t off,
+ const void *buf, tdb_len_t len)
{
- if (len == 0) {
- return 0;
- }
+ enum TDB_ERROR ecode;
- if (tdb->read_only) {
- tdb->ecode = TDB_ERR_RDONLY;
- return -1;
+ if (tdb->flags & TDB_RDONLY) {
+ return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
+ "Write to read-only database");
}
- if (tdb->methods->oob(tdb, off + len, 0) != 0)
- return -1;
+ ecode = tdb->tdb2.io->oob(tdb, off, len, false);
+ if (ecode != TDB_SUCCESS) {
+ return ecode;
+ }
- if (tdb->map_ptr) {
- memcpy(off + (char *)tdb->map_ptr, buf, len);
+ if (tdb->file->map_ptr) {
+ memcpy(off + (char *)tdb->file->map_ptr, buf, len);
} else {
- if (!tdb_pwrite_all(tdb->fd, buf, len, off)) {
- tdb->ecode = TDB_ERR_IO;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "tdb_write failed at %llu len=%llu (%s)\n",
- off, len, strerror(errno));
- return -1;
+ ssize_t ret;
+ ret = pwrite(tdb->file->fd, buf, len, off);
+ if (ret != len) {
+ /* This shouldn't happen: we avoid sparse files. */
+ if (ret >= 0)
+ errno = ENOSPC;
+
+ return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_write: %zi at %zu len=%zu (%s)",
+ ret, (size_t)off, (size_t)len,
+ strerror(errno));
}
}
- return 0;
+ return TDB_SUCCESS;
}
/* read a lump of data at a specified offset */
-static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
- tdb_len_t len)
+static enum TDB_ERROR tdb_read(struct tdb_context *tdb, tdb_off_t off,
+ void *buf, tdb_len_t len)
{
- if (tdb->methods->oob(tdb, off + len, 0) != 0) {
- return -1;
+ enum TDB_ERROR ecode;
+
+ ecode = tdb->tdb2.io->oob(tdb, off, len, false);
+ if (ecode != TDB_SUCCESS) {
+ return ecode;
}
- if (tdb->map_ptr) {
- memcpy(buf, off + (char *)tdb->map_ptr, len);
+ if (tdb->file->map_ptr) {
+ memcpy(buf, off + (char *)tdb->file->map_ptr, len);
} else {
- if (!tdb_pread_all(tdb->fd, buf, len, off)) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB_ERR_IO;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "tdb_read failed at %lld "
- "len=%lld (%s) map_size=%lld\n",
- (long long)off, (long long)len,
- strerror(errno),
- (long long)tdb->map_size);
- return -1;
+ ssize_t r = pread(tdb->file->fd, buf, len, off);
+ if (r != len) {
+ return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_read failed with %zi at %zu "
+ "len=%zu (%s) map_size=%zu",
+ r, (size_t)off, (size_t)len,
+ strerror(errno),
+ (size_t)tdb->file->map_size);
}
}
- return 0;
+ return TDB_SUCCESS;
}
-int tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
- const void *rec, size_t len)
+enum TDB_ERROR tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
+ const void *rec, size_t len)
{
- int ret;
+ enum TDB_ERROR ecode;
+
if (unlikely((tdb->flags & TDB_CONVERT))) {
void *conv = malloc(len);
if (!conv) {
- tdb->ecode = TDB_ERR_OOM;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "tdb_write: no memory converting %zu bytes\n",
- len);
- return -1;
+ return tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "tdb_write: no memory converting"
+ " %zu bytes", len);
}
memcpy(conv, rec, len);
- ret = tdb->methods->write(tdb, off,
- tdb_convert(tdb, conv, len), len);
+ ecode = tdb->tdb2.io->twrite(tdb, off,
+ tdb_convert(tdb, conv, len), len);
free(conv);
- } else
- ret = tdb->methods->write(tdb, off, rec, len);
-
- return ret;
+ } else {
+ ecode = tdb->tdb2.io->twrite(tdb, off, rec, len);
+ }
+ return ecode;
}
-int tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
- void *rec, size_t len)
+enum TDB_ERROR tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
+ void *rec, size_t len)
{
- int ret = tdb->methods->read(tdb, off, rec, len);
+ enum TDB_ERROR ecode = tdb->tdb2.io->tread(tdb, off, rec, len);
tdb_convert(tdb, rec, len);
- return ret;
+ return ecode;
}
-int tdb_write_off(struct tdb_context *tdb, tdb_off_t off, tdb_off_t val)
+enum TDB_ERROR tdb_write_off(struct tdb_context *tdb,
+ tdb_off_t off, tdb_off_t val)
{
+ 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->tdb2.io->direct(tdb, off, sizeof(*p),
+ true);
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_PTR_ERR(p);
+ }
+ if (p) {
+ *p = val;
+ return TDB_SUCCESS;
+ }
+ }
return tdb_write_convert(tdb, off, &val, sizeof(val));
}
static void *_tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset,
tdb_len_t len, unsigned int prefix)
{
- void *buf;
+ unsigned char *buf;
+ enum TDB_ERROR ecode;
/* some systems don't like zero length malloc */
buf = malloc(prefix + len ? prefix + len : 1);
- if (unlikely(!buf)) {
- tdb->ecode = TDB_ERR_OOM;
- tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv,
- "tdb_alloc_read malloc failed len=%lld\n",
- (long long)prefix + len);
- } else if (unlikely(tdb->methods->read(tdb, offset, buf+prefix, len))) {
- free(buf);
- buf = NULL;
+ if (!buf) {
+ tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_USE_ERROR,
+ "tdb_alloc_read malloc failed len=%zu",
+ (size_t)(prefix + len));
+ return TDB_ERR_PTR(TDB_ERR_OOM);
+ } else {
+ ecode = tdb->tdb2.io->tread(tdb, offset, buf+prefix, len);
+ if (unlikely(ecode != TDB_SUCCESS)) {
+ free(buf);
+ return TDB_ERR_PTR(ecode);
+ }
}
return buf;
}
return _tdb_alloc_read(tdb, offset, len, 0);
}
-static int fill(struct tdb_context *tdb,
- const void *buf, size_t size,
- tdb_off_t off, tdb_len_t len)
+static enum TDB_ERROR fill(struct tdb_context *tdb,
+ const void *buf, size_t size,
+ tdb_off_t off, tdb_len_t len)
{
while (len) {
size_t n = len > size ? size : len;
-
- if (!tdb_pwrite_all(tdb->fd, buf, n, off)) {
- tdb->ecode = TDB_ERR_IO;
- tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
- "fill write failed: giving up!\n");
- return -1;
+ ssize_t ret = pwrite(tdb->file->fd, buf, n, off);
+ if (ret != n) {
+ if (ret >= 0)
+ errno = ENOSPC;
+
+ return tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "fill failed:"
+ " %zi at %zu len=%zu (%s)",
+ ret, (size_t)off, (size_t)len,
+ strerror(errno));
}
len -= n;
off += n;
}
- return 0;
+ return TDB_SUCCESS;
}
/* expand a file. we prefer to use ftruncate, as that is what posix
says to use for mmap expansion */
-static int tdb_expand_file(struct tdb_context *tdb, tdb_len_t addition)
+static enum TDB_ERROR tdb_expand_file(struct tdb_context *tdb,
+ tdb_len_t addition)
{
char buf[8192];
+ enum TDB_ERROR ecode;
- if (tdb->read_only) {
- tdb->ecode = TDB_ERR_RDONLY;
- return -1;
+ if (tdb->flags & TDB_RDONLY) {
+ return tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
+ "Expand on read-only database");
}
if (tdb->flags & TDB_INTERNAL) {
- char *new = realloc(tdb->map_ptr, tdb->map_size + addition);
+ char *new = realloc(tdb->file->map_ptr,
+ tdb->file->map_size + addition);
if (!new) {
- tdb->ecode = TDB_ERR_OOM;
- return -1;
+ return tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
+ "No memory to expand database");
}
- tdb->map_ptr = new;
- tdb->map_size += addition;
+ tdb->file->map_ptr = new;
+ tdb->file->map_size += addition;
} else {
/* Unmap before trying to write; old TDB claimed OpenBSD had
* problem with this otherwise. */
- tdb_munmap(tdb);
+ tdb_munmap(tdb->file);
/* If this fails, we try to fill anyway. */
- if (ftruncate(tdb->fd, tdb->map_size + addition))
+ if (ftruncate(tdb->file->fd, tdb->file->map_size + addition))
;
/* now fill the file with something. This ensures that the
file isn't sparse, which would be very bad if we ran out of
disk. This must be done with write, not via mmap */
memset(buf, 0x43, sizeof(buf));
- if (fill(tdb, buf, sizeof(buf), tdb->map_size, addition) == -1)
- return -1;
- tdb->map_size += addition;
+ ecode = fill(tdb, buf, sizeof(buf), tdb->file->map_size,
+ addition);
+ if (ecode != TDB_SUCCESS)
+ return ecode;
+ tdb->file->map_size += addition;
tdb_mmap(tdb);
}
- return 0;
+ return TDB_SUCCESS;
}
-/* This is only neded for tdb_access_commit, but used everywhere to simplify. */
-struct tdb_access_hdr {
- tdb_off_t off;
- tdb_len_t len;
- bool convert;
-};
-
const void *tdb_access_read(struct tdb_context *tdb,
tdb_off_t off, tdb_len_t len, bool convert)
{
- const void *ret = NULL;
+ void *ret = NULL;
- if (likely(!(tdb->flags & TDB_CONVERT)))
- ret = tdb_direct(tdb, off, len);
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
+ ret = tdb->tdb2.io->direct(tdb, off, len, false);
+ if (TDB_PTR_IS_ERR(ret)) {
+ return ret;
+ }
+ }
if (!ret) {
struct tdb_access_hdr *hdr;
hdr = _tdb_alloc_read(tdb, off, len, sizeof(*hdr));
- if (hdr) {
- ret = hdr + 1;
- if (convert)
- tdb_convert(tdb, (void *)ret, len);
+ if (TDB_PTR_IS_ERR(hdr)) {
+ return 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 (likely(!(tdb->flags & TDB_CONVERT)))
- ret = tdb_direct(tdb, off, len);
+ 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->tdb2.io->direct(tdb, off, len, true);
+
+ if (TDB_PTR_IS_ERR(ret)) {
+ return ret;
+ }
+ }
if (!ret) {
struct tdb_access_hdr *hdr;
hdr = _tdb_alloc_read(tdb, off, len, sizeof(*hdr));
- if (hdr) {
- hdr->off = off;
- hdr->len = len;
- hdr->convert = convert;
- ret = hdr + 1;
- if (convert)
- tdb_convert(tdb, (void *)ret, len);
+ if (TDB_PTR_IS_ERR(hdr)) {
+ return hdr;
}
+ hdr->next = tdb->tdb2.access;
+ tdb->tdb2.access = hdr;
+ hdr->off = off;
+ hdr->len = len;
+ hdr->convert = convert;
+ ret = hdr + 1;
+ if (convert)
+ tdb_convert(tdb, (void *)ret, len);
} else
- tdb->direct_access++;
+ tdb->tdb2.direct_access++;
return ret;
}
-void tdb_access_release(struct tdb_context *tdb, const void *p)
+static struct tdb_access_hdr **find_hdr(struct tdb_context *tdb, const void *p)
{
- if (!tdb->map_ptr
- || (char *)p < (char *)tdb->map_ptr
- || (char *)p >= (char *)tdb->map_ptr + tdb->map_size)
- free((struct tdb_access_hdr *)p - 1);
- else
- tdb->direct_access--;
+ struct tdb_access_hdr **hp;
+
+ for (hp = &tdb->tdb2.access; *hp; hp = &(*hp)->next) {
+ if (*hp + 1 == p)
+ return hp;
+ }
+ return NULL;
}
-int tdb_access_commit(struct tdb_context *tdb, void *p)
+void tdb_access_release(struct tdb_context *tdb, const void *p)
{
- int ret = 0;
-
- if (!tdb->map_ptr
- || (char *)p < (char *)tdb->map_ptr
- || (char *)p >= (char *)tdb->map_ptr + tdb->map_size) {
- struct tdb_access_hdr *hdr;
+ struct tdb_access_hdr *hdr, **hp = find_hdr(tdb, p);
- hdr = (struct tdb_access_hdr *)p - 1;
- if (hdr->convert)
- ret = tdb_write_convert(tdb, hdr->off, p, hdr->len);
- else
- ret = tdb_write(tdb, hdr->off, p, hdr->len);
+ if (hp) {
+ hdr = *hp;
+ *hp = hdr->next;
free(hdr);
} else
- tdb->direct_access--;
-
- return ret;
+ tdb->tdb2.direct_access--;
}
-#if 0
-/* write a lump of data at a specified offset */
-static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
- const void *buf, tdb_len_t len)
+enum TDB_ERROR tdb_access_commit(struct tdb_context *tdb, void *p)
{
- if (len == 0) {
- return 0;
- }
-
- if (tdb->read_only || tdb->traverse_read) {
- tdb->ecode = TDB_ERR_RDONLY;
- return -1;
- }
+ struct tdb_access_hdr *hdr, **hp = find_hdr(tdb, p);
+ enum TDB_ERROR ecode;
- if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
- return -1;
-
- if (tdb->map_ptr) {
- memcpy(off + (char *)tdb->map_ptr, buf, len);
+ if (hp) {
+ hdr = *hp;
+ if (hdr->convert)
+ ecode = tdb_write_convert(tdb, hdr->off, p, hdr->len);
+ else
+ ecode = tdb_write(tdb, hdr->off, p, hdr->len);
+ *hp = hdr->next;
+ free(hdr);
} else {
- ssize_t written = pwrite(tdb->fd, buf, len, off);
- if ((written != (ssize_t)len) && (written != -1)) {
- /* try once more */
- tdb->ecode = TDB_ERR_IO;
- TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
- "%d of %d bytes at %d, trying once more\n",
- (int)written, len, off));
- written = pwrite(tdb->fd, (const char *)buf+written,
- len-written,
- off+written);
- }
- if (written == -1) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB_ERR_IO;
- TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
- "len=%d (%s)\n", off, len, strerror(errno)));
- return -1;
- } else if (written != (ssize_t)len) {
- tdb->ecode = TDB_ERR_IO;
- TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
- "write %d bytes at %d in two attempts\n",
- len, off));
- return -1;
- }
+ tdb->tdb2.direct_access--;
+ ecode = TDB_SUCCESS;
}
- return 0;
-}
-
-
-/*
- 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 tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
-{
- uint32_t h = *chain;
- if (tdb->map_ptr) {
- for (;h < tdb->header.hash_size;h++) {
- if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
- break;
- }
- }
- } else {
- uint32_t off=0;
- for (;h < tdb->header.hash_size;h++) {
- if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
- break;
- }
- }
- }
- (*chain) = h;
+ return ecode;
}
-/* read/write a tdb_off_t */
-int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
+static void *tdb_direct(struct tdb_context *tdb, tdb_off_t off, size_t len,
+ bool write_mode)
{
- return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
+ enum TDB_ERROR ecode;
+
+ if (unlikely(!tdb->file->map_ptr))
+ return NULL;
+
+ ecode = tdb_oob(tdb, off, len, false);
+ if (unlikely(ecode != TDB_SUCCESS))
+ return TDB_ERR_PTR(ecode);
+ return (char *)tdb->file->map_ptr + off;
}
-int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
+void tdb_inc_seqnum(struct tdb_context *tdb)
{
- tdb_off_t off = *d;
- return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
-}
+ tdb_off_t seq;
+ if (tdb->flags & TDB_VERSION1) {
+ tdb1_increment_seqnum_nonblock(tdb);
+ return;
+ }
-/* read/write a record */
-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_BAD_MAGIC(rec)) {
- /* Ensure ecode is set for log fn. */
- tdb->ecode = TDB_ERR_CORRUPT;
- TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
- return -1;
- }
- return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
-}
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
+ int64_t *direct;
+
+ direct = tdb->tdb2.io->direct(tdb,
+ offsetof(struct tdb_header,
+ seqnum),
+ sizeof(*direct), true);
+ if (likely(direct)) {
+ /* Don't let it go negative, even briefly */
+ if (unlikely((*direct) + 1) < 0)
+ *direct = 0;
+ (*direct)++;
+ return;
+ }
+ }
-int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
-{
- struct tdb_record r = *rec;
- return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
+ seq = tdb_read_off(tdb, offsetof(struct tdb_header, seqnum));
+ if (!TDB_OFF_IS_ERR(seq)) {
+ seq++;
+ if (unlikely((int64_t)seq < 0))
+ seq = 0;
+ tdb_write_off(tdb, offsetof(struct tdb_header, seqnum), seq);
+ }
}
-#endif
static const struct tdb_methods io_methods = {
tdb_read,
tdb_write,
tdb_oob,
tdb_expand_file,
+ tdb_direct,
};
/*
*/
void tdb_io_init(struct tdb_context *tdb)
{
- tdb->methods = &io_methods;
+ tdb->tdb2.io = &io_methods;
}
projects / ccan / blobdiff