r = tdb_access_read(tdb, off, sizeof(*r), true);
if (TDB_PTR_IS_ERR(r)) {
- tdb->ecode = TDB_PTR_ERR(r);
/* FIXME */
return 0;
}
key = tdb_access_read(tdb, off + sizeof(*r), klen, false);
if (TDB_PTR_IS_ERR(key)) {
- tdb->ecode = TDB_PTR_ERR(key);
return 0;
}
if (!next) {
next = alloc(tdb, 0, sizeof(struct tdb_chain), 0,
TDB_CHAIN_MAGIC, false);
- if (next == TDB_OFF_ERR)
- return tdb->ecode;
+ if (TDB_OFF_IS_ERR(next))
+ return next;
ecode = zero_out(tdb,
next+sizeof(struct tdb_used_record),
sizeof(struct tdb_chain));
}
subhash = alloc(tdb, 0, subsize, 0, magic, false);
- if (subhash == TDB_OFF_ERR) {
- return tdb->ecode;
+ if (TDB_OFF_IS_ERR(subhash)) {
+ return subhash;
}
ecode = zero_out(tdb, subhash + sizeof(struct tdb_used_record),
/* lock/unlock one hash chain. This is meant to be used to reduce
contention - it cannot guarantee how many records will be locked */
-int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
+enum TDB_ERROR tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
{
- tdb->ecode = chainlock(tdb, &key, F_WRLCK, TDB_LOCK_WAIT,
- "tdb_chainlock");
- if (tdb->ecode == TDB_SUCCESS)
- return 0;
- return -1;
-
+ return tdb->last_error = chainlock(tdb, &key, F_WRLCK, TDB_LOCK_WAIT,
+ "tdb_chainlock");
}
-int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
+enum TDB_ERROR tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
{
uint64_t h = tdb_hash(tdb, key.dptr, key.dsize);
tdb_off_t lockstart, locksize;
unsigned int group, gbits;
- enum TDB_ERROR ecode;
gbits = TDB_TOPLEVEL_HASH_BITS - TDB_HASH_GROUP_BITS;
group = bits_from(h, 64 - gbits, gbits);
lockstart = hlock_range(group, &locksize);
tdb_trace_1rec(tdb, "tdb_chainunlock", key);
- ecode = tdb_unlock_hashes(tdb, lockstart, locksize, F_WRLCK);
- if (ecode != TDB_SUCCESS) {
- tdb->ecode = ecode;
- return -1;
- }
- return 0;
+ return tdb->last_error = tdb_unlock_hashes(tdb, lockstart, locksize,
+ F_WRLCK);
}