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_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_PTR_ERR(val);
+ }
for (i = 0; i < num; i++) {
if (!val[i])
enum TDB_ERROR ecode = TDB_SUCCESS;
assert(!tdb->read_only);
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_PTR_ERR(p);
+ }
if (p) {
memset(p, 0, len);
return ecode;
if (likely(!(tdb->flags & TDB_CONVERT))) {
tdb_off_t *p = tdb->methods->direct(tdb, off, sizeof(*p),
false);
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_PTR_ERR(p);
+ }
if (p)
return *p;
}
ecode = tdb_read_convert(tdb, off, &ret, sizeof(ret));
if (ecode != TDB_SUCCESS) {
- tdb->ecode = ecode;
- return TDB_OFF_ERR;
+ return ecode;
}
return ret;
}
"Write to read-only database");
}
- /* FIXME: Bogus optimization? */
- if (len == 0) {
- return TDB_SUCCESS;
- }
-
ecode = tdb->methods->oob(tdb, off + len, 0);
if (ecode != TDB_SUCCESS) {
return ecode;
} else {
ssize_t ret;
ret = pwrite(tdb->fd, buf, len, off);
- if (ret < len) {
+ if (ret != len) {
/* This shouldn't happen: we avoid sparse files. */
if (ret >= 0)
errno = ENOSPC;
if (likely(!(tdb->flags & TDB_CONVERT))) {
tdb_off_t *p = tdb->methods->direct(tdb, off, sizeof(*p),
true);
+ if (TDB_PTR_IS_ERR(p)) {
+ return TDB_PTR_ERR(p);
+ }
if (p) {
*p = val;
return TDB_SUCCESS;
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->methods->tread(tdb, offset, buf+prefix, len);
if (unlikely(ecode != TDB_SUCCESS)) {
- tdb->ecode = ecode;
free(buf);
- buf = NULL;
+ return TDB_ERR_PTR(ecode);
}
}
return buf;
while (len) {
size_t n = len > size ? size : len;
ssize_t ret = pwrite(tdb->fd, buf, n, off);
- if (ret < n) {
+ if (ret != n) {
if (ret >= 0)
errno = ENOSPC;
{
const void *ret = NULL;
- if (likely(!(tdb->flags & TDB_CONVERT)))
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
ret = tdb->methods->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) {
- hdr->next = tdb->access;
- tdb->access = hdr;
- ret = hdr + 1;
- if (convert)
- tdb_convert(tdb, (void *)ret, len);
+ if (TDB_PTR_IS_ERR(hdr)) {
+ return hdr;
+ }
+ hdr->next = tdb->access;
+ tdb->access = hdr;
+ ret = hdr + 1;
+ if (convert) {
+ tdb_convert(tdb, (void *)ret, len);
}
} else
tdb->direct_access++;
if (tdb->read_only) {
tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Write to read-only database");
- return NULL;
+ return TDB_ERR_PTR(TDB_ERR_RDONLY);
}
- if (likely(!(tdb->flags & TDB_CONVERT)))
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
ret = tdb->methods->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->next = tdb->access;
- tdb->access = 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->access;
+ tdb->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++;
static void *tdb_direct(struct tdb_context *tdb, tdb_off_t off, size_t len,
bool write_mode)
{
+ enum TDB_ERROR ecode;
+
if (unlikely(!tdb->map_ptr))
return NULL;
- if (unlikely(tdb_oob(tdb, off + len, true) != TDB_SUCCESS))
- return NULL;
+ ecode = tdb_oob(tdb, off + len, true);
+ if (unlikely(ecode != TDB_SUCCESS))
+ return TDB_ERR_PTR(ecode);
return (char *)tdb->map_ptr + off;
}