uint64_t klen, hash;
r = tdb_access_read(tdb, off, sizeof(*r), true);
- if (!r)
+ if (TDB_PTR_IS_ERR(r)) {
+ tdb->ecode = TDB_PTR_ERR(r);
/* FIXME */
return 0;
+ }
klen = rec_key_length(r);
tdb_access_release(tdb, r);
key = tdb_access_read(tdb, off + sizeof(*r), klen, false);
- if (!key)
+ if (TDB_PTR_IS_ERR(key)) {
+ tdb->ecode = TDB_PTR_ERR(key);
return 0;
+ }
hash = tdb_hash(tdb, key, klen);
tdb_access_release(tdb, key);
}
rkey = tdb_access_read(tdb, off + sizeof(*rec), key->dsize, false);
- if (!rkey)
+ if (TDB_PTR_IS_ERR(rkey)) {
+ tdb->ecode = TDB_PTR_ERR(rkey);
return ret;
+ }
if (memcmp(rkey, key->dptr, key->dsize) == 0)
ret = true;
else
group = tdb_access_write(tdb, h.group_start,
sizeof(*group) << TDB_HASH_GROUP_BITS, true);
- if (!group)
+ if (TDB_PTR_IS_ERR(group)) {
+ tdb->ecode = TDB_PTR_ERR(group);
return -1;
+ }
force_into_group(group, h.home_bucket, encode_offset(off, &h));
ecode = tdb_access_commit(tdb, group);
if (ecode != TDB_SUCCESS) {
kbuf->dsize);
}
tdb_unlock_hashes(tdb, hl_start, hl_range, F_RDLCK);
- return kbuf->dptr ? 1 : -1;
+ if (TDB_PTR_IS_ERR(kbuf->dptr)) {
+ tdb->ecode = TDB_PTR_ERR(kbuf->dptr);
+ return -1;
+ }
+ return 1;
}
tdb_unlock_hashes(tdb, hl_start, hl_range, F_RDLCK);
/* 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)
+ if (TDB_PTR_IS_ERR(val)) {
+ tdb->ecode = TDB_PTR_ERR(val);
return end;
+ }
for (i = 0; i < (end - start); i++) {
if (val[i])
/* Zero vs non-zero is the same unconverted: minor optimization. */
val = tdb_access_read(tdb, off, num * sizeof(tdb_off_t), false);
- if (!val)
+ if (TDB_PTR_IS_ERR(val)) {
+ tdb->ecode = TDB_PTR_ERR(val);
return num;
+ }
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)) {
+ tdb->ecode = TDB_PTR_ERR(p);
+ return TDB_OFF_ERR;
+ }
if (p)
return *p;
}
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;
{
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;
}