tdb2: rework some io.c functions to encode errors in their pointer returns.

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.

ccan/tdb2/check.c

@@ -237,8 +237,10 @@ static bool check_hash_tree(struct tdb_context *tdb,
 			       sizeof(tdb_off_t)
 			       << (group_bits + TDB_HASH_GROUP_BITS),
 			       true);
-	if (!hash)
+	if (TDB_PTR_IS_ERR(hash)) {
+		tdb->ecode = TDB_PTR_ERR(hash);
 		return false;
+	}
 
 	for (g = 0; g < (1 << group_bits); g++) {
 		const tdb_off_t *group = hash + (g << TDB_HASH_GROUP_BITS);
@@ -389,8 +391,10 @@ static bool check_hash_tree(struct tdb_context *tdb,
 						   off + sizeof(rec),
 						   key.dsize + data.dsize,
 						   false);
-				if (!key.dptr)
+				if (TDB_PTR_IS_ERR(key.dptr)) {
+					tdb->ecode = TDB_PTR_ERR(key.dptr);
 					goto fail;
+				}
 				data.dptr = key.dptr + key.dsize;
 				if (check(key, data, private_data) != 0)
 					goto fail;

ccan/tdb2/free.c

@@ -297,8 +297,10 @@ static int coalesce(struct tdb_context *tdb,
 		unsigned ftable, bucket;
 
 		r = tdb_access_read(tdb, end, sizeof(*r), true);
-		if (!r)
+		if (TDB_PTR_IS_ERR(r)) {
+			tdb->ecode = TDB_PTR_ERR(r);
 			goto err;
+		}
 
 		if (frec_magic(r) != TDB_FREE_MAGIC
 		    || frec_ftable(r) == TDB_FTABLE_NONE) {
@@ -443,8 +445,10 @@ again:
 		tdb_off_t next;
 
 		r = tdb_access_read(tdb, off, sizeof(*r), true);
-		if (!r)
+		if (TDB_PTR_IS_ERR(r)) {
+			tdb->ecode = TDB_PTR_ERR(r);
 			goto unlock_err;
+		}
 
 		if (frec_magic(r) != TDB_FREE_MAGIC) {
 			tdb_access_release(tdb, r);

ccan/tdb2/hash.c

@@ -47,16 +47,20 @@ uint64_t hash_record(struct tdb_context *tdb, tdb_off_t off)
 	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);
@@ -92,8 +96,10 @@ static bool key_matches(struct tdb_context *tdb,
 	}
 
 	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
@@ -490,8 +496,10 @@ static int add_to_subhash(struct tdb_context *tdb, tdb_off_t subhash,
 
 	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) {
@@ -808,7 +816,11 @@ int next_in_hash(struct tdb_context *tdb,
 							    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);

ccan/tdb2/io.c

@@ -143,8 +143,10 @@ uint64_t tdb_find_nonzero_off(struct tdb_context *tdb,
 	/* 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])
@@ -163,8 +165,10 @@ uint64_t tdb_find_zero_off(struct tdb_context *tdb, tdb_off_t off,
 
 	/* 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])
@@ -181,6 +185,9 @@ enum TDB_ERROR zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
 	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;
@@ -205,6 +212,10 @@ tdb_off_t tdb_read_off(struct tdb_context *tdb, tdb_off_t off)
 	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;
 	}
@@ -325,6 +336,9 @@ enum TDB_ERROR tdb_write_off(struct tdb_context *tdb,
 	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;
@@ -345,12 +359,12 @@ static void *_tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset,
 		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;
@@ -433,18 +447,24 @@ const void *tdb_access_read(struct tdb_context *tdb,
 {
 	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++;
@@ -460,25 +480,31 @@ void *tdb_access_write(struct tdb_context *tdb,
 	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++;
 
@@ -532,11 +558,14 @@ enum TDB_ERROR tdb_access_commit(struct tdb_context *tdb, void *p)
 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;
 }
 

ccan/tdb2/summary.c

@@ -26,8 +26,10 @@ static int count_hash(struct tdb_context *tdb,
 	unsigned int i, count = 0;
 
 	h = tdb_access_read(tdb, hash_off, sizeof(*h) << bits, true);
-	if (!h)
+	if (TDB_PTR_IS_ERR(h)) {
+		tdb->ecode = TDB_PTR_ERR(h);
 		return -1;
+	}
 	for (i = 0; i < (1 << bits); i++)
 		count += (h[i] != 0);
 
@@ -58,8 +60,10 @@ static bool summarize(struct tdb_context *tdb,
 		} *p;
 		/* We might not be able to get the whole thing. */
 		p = tdb_access_read(tdb, off, sizeof(p->f), true);
-		if (!p)
+		if (TDB_PTR_IS_ERR(p)) {
+			tdb->ecode = TDB_PTR_ERR(p);
 			return false;
+		}
 		if (p->r.magic == TDB_RECOVERY_INVALID_MAGIC
 		    || p->r.magic == TDB_RECOVERY_MAGIC) {
 			if (unc) {

ccan/tdb2/tdb.c

@@ -631,6 +631,10 @@ struct tdb_data tdb_fetch(struct tdb_context *tdb, struct tdb_data key)
 		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);