summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
7d63125)
This causes a subtle enhancement in tdb_direct(): it previously
returned NULL on both "can't use direct access" or "some error
occurred", as the caller always uses read/write functions as a
fallback anyway. Now we distinguish the error case.
sizeof(tdb_off_t)
<< (group_bits + TDB_HASH_GROUP_BITS),
true);
sizeof(tdb_off_t)
<< (group_bits + TDB_HASH_GROUP_BITS),
true);
+ if (TDB_PTR_IS_ERR(hash)) {
+ tdb->ecode = TDB_PTR_ERR(hash);
for (g = 0; g < (1 << group_bits); g++) {
const tdb_off_t *group = hash + (g << TDB_HASH_GROUP_BITS);
for (g = 0; g < (1 << group_bits); g++) {
const tdb_off_t *group = hash + (g << TDB_HASH_GROUP_BITS);
off + sizeof(rec),
key.dsize + data.dsize,
false);
off + sizeof(rec),
key.dsize + data.dsize,
false);
+ if (TDB_PTR_IS_ERR(key.dptr)) {
+ tdb->ecode = TDB_PTR_ERR(key.dptr);
data.dptr = key.dptr + key.dsize;
if (check(key, data, private_data) != 0)
goto fail;
data.dptr = key.dptr + key.dsize;
if (check(key, data, private_data) != 0)
goto fail;
unsigned ftable, bucket;
r = tdb_access_read(tdb, end, sizeof(*r), true);
unsigned ftable, bucket;
r = tdb_access_read(tdb, end, sizeof(*r), true);
+ if (TDB_PTR_IS_ERR(r)) {
+ tdb->ecode = TDB_PTR_ERR(r);
if (frec_magic(r) != TDB_FREE_MAGIC
|| frec_ftable(r) == TDB_FTABLE_NONE) {
if (frec_magic(r) != TDB_FREE_MAGIC
|| frec_ftable(r) == TDB_FTABLE_NONE) {
tdb_off_t next;
r = tdb_access_read(tdb, off, sizeof(*r), true);
tdb_off_t next;
r = tdb_access_read(tdb, off, sizeof(*r), true);
+ if (TDB_PTR_IS_ERR(r)) {
+ tdb->ecode = TDB_PTR_ERR(r);
if (frec_magic(r) != TDB_FREE_MAGIC) {
tdb_access_release(tdb, r);
if (frec_magic(r) != TDB_FREE_MAGIC) {
tdb_access_release(tdb, r);
uint64_t klen, hash;
r = tdb_access_read(tdb, off, sizeof(*r), true);
uint64_t klen, hash;
r = tdb_access_read(tdb, off, sizeof(*r), true);
+ if (TDB_PTR_IS_ERR(r)) {
+ tdb->ecode = TDB_PTR_ERR(r);
klen = rec_key_length(r);
tdb_access_release(tdb, r);
key = tdb_access_read(tdb, off + sizeof(*r), klen, false);
klen = rec_key_length(r);
tdb_access_release(tdb, r);
key = tdb_access_read(tdb, off + sizeof(*r), klen, false);
+ if (TDB_PTR_IS_ERR(key)) {
+ tdb->ecode = TDB_PTR_ERR(key);
hash = tdb_hash(tdb, key, klen);
tdb_access_release(tdb, key);
hash = tdb_hash(tdb, key, klen);
tdb_access_release(tdb, key);
}
rkey = tdb_access_read(tdb, off + sizeof(*rec), key->dsize, false);
}
rkey = tdb_access_read(tdb, off + sizeof(*rec), key->dsize, false);
+ if (TDB_PTR_IS_ERR(rkey)) {
+ tdb->ecode = TDB_PTR_ERR(rkey);
if (memcmp(rkey, key->dptr, key->dsize) == 0)
ret = true;
else
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);
group = tdb_access_write(tdb, h.group_start,
sizeof(*group) << TDB_HASH_GROUP_BITS, true);
+ if (TDB_PTR_IS_ERR(group)) {
+ tdb->ecode = TDB_PTR_ERR(group);
force_into_group(group, h.home_bucket, encode_offset(off, &h));
ecode = tdb_access_commit(tdb, group);
if (ecode != TDB_SUCCESS) {
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);
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);
}
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);
/* 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 (TDB_PTR_IS_ERR(val)) {
+ tdb->ecode = TDB_PTR_ERR(val);
for (i = 0; i < (end - start); i++) {
if (val[i])
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);
/* 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)) {
+ tdb->ecode = TDB_PTR_ERR(val);
for (i = 0; i < num; i++) {
if (!val[i])
for (i = 0; i < num; i++) {
if (!val[i])
enum TDB_ERROR ecode = TDB_SUCCESS;
assert(!tdb->read_only);
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 (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 (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 (likely(!(tdb->flags & TDB_CONVERT))) {
tdb_off_t *p = tdb->methods->direct(tdb, off, sizeof(*p),
true);
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;
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));
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)) {
} else {
ecode = tdb->methods->tread(tdb, offset, buf+prefix, len);
if (unlikely(ecode != TDB_SUCCESS)) {
+ return TDB_ERR_PTR(ecode);
{
const void *ret = NULL;
{
const void *ret = NULL;
- if (likely(!(tdb->flags & TDB_CONVERT)))
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
ret = tdb->methods->direct(tdb, off, len, false);
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 (!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++;
}
} else
tdb->direct_access++;
if (tdb->read_only) {
tdb_logerr(tdb, TDB_ERR_RDONLY, TDB_LOG_USE_ERROR,
"Write to read-only database");
if (tdb->read_only) {
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)))
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
ret = tdb->methods->direct(tdb, off, len, true);
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 (!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++;
} else
tdb->direct_access++;
static void *tdb_direct(struct tdb_context *tdb, tdb_off_t off, size_t len,
bool write_mode)
{
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->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;
}
return (char *)tdb->map_ptr + off;
}
unsigned int i, count = 0;
h = tdb_access_read(tdb, hash_off, sizeof(*h) << bits, true);
unsigned int i, count = 0;
h = tdb_access_read(tdb, hash_off, sizeof(*h) << bits, true);
+ if (TDB_PTR_IS_ERR(h)) {
+ tdb->ecode = TDB_PTR_ERR(h);
for (i = 0; i < (1 << bits); i++)
count += (h[i] != 0);
for (i = 0; i < (1 << bits); i++)
count += (h[i] != 0);
} *p;
/* We might not be able to get the whole thing. */
p = tdb_access_read(tdb, off, sizeof(p->f), true);
} *p;
/* We might not be able to get the whole thing. */
p = tdb_access_read(tdb, off, sizeof(p->f), true);
+ if (TDB_PTR_IS_ERR(p)) {
+ tdb->ecode = TDB_PTR_ERR(p);
if (p->r.magic == TDB_RECOVERY_INVALID_MAGIC
|| p->r.magic == TDB_RECOVERY_MAGIC) {
if (unc) {
if (p->r.magic == TDB_RECOVERY_INVALID_MAGIC
|| p->r.magic == TDB_RECOVERY_MAGIC) {
if (unc) {
ret.dsize = rec_data_length(&rec);
ret.dptr = tdb_alloc_read(tdb, off + sizeof(rec) + key.dsize,
ret.dsize);
ret.dsize = rec_data_length(&rec);
ret.dptr = tdb_alloc_read(tdb, off + sizeof(rec) + key.dsize,
ret.dsize);
+ if (TDB_PTR_IS_ERR(ret.dptr)) {
+ tdb->ecode = TDB_PTR_ERR(ret.dptr);
+ ret = tdb_null;
+ }
}
tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_RDLCK);
}
tdb_unlock_hashes(tdb, h.hlock_start, h.hlock_range, F_RDLCK);