X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftdb2%2Fcheck.c;h=d4f1d343bf0268546aca47d72158bd6bab3b83eb;hb=3d917ba6dffe2029608a3d4c870dfdb4033ca4c9;hp=4cd92b43c040a30c40e4e952e05aac5deb0a13e9;hpb=0aa58f6e6017138a78ce4e86fb758732719acaca;p=ccan diff --git a/ccan/tdb2/check.c b/ccan/tdb2/check.c index 4cd92b43..d4f1d343 100644 --- a/ccan/tdb2/check.c +++ b/ccan/tdb2/check.c @@ -34,16 +34,20 @@ static bool check_header(struct tdb_context *tdb, tdb_off_t *recovery) { uint64_t hash_test; struct tdb_header hdr; + enum TDB_ERROR ecode; - if (tdb_read_convert(tdb, 0, &hdr, sizeof(hdr)) == -1) + ecode = tdb_read_convert(tdb, 0, &hdr, sizeof(hdr)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } /* magic food should not be converted, so convert back. */ tdb_convert(tdb, hdr.magic_food, sizeof(hdr.magic_food)); hash_test = TDB_HASH_MAGIC; hash_test = tdb_hash(tdb, &hash_test, sizeof(hash_test)); if (hdr.hash_test != hash_test) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "check: hash test %llu should be %llu", (long long)hdr.hash_test, (long long)hash_test); @@ -51,7 +55,7 @@ static bool check_header(struct tdb_context *tdb, tdb_off_t *recovery) } if (strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "check: bad magic '%.*s'", (unsigned)sizeof(hdr.magic_food), hdr.magic_food); return false; @@ -60,7 +64,7 @@ static bool check_header(struct tdb_context *tdb, tdb_off_t *recovery) *recovery = hdr.recovery; if (*recovery) { if (*recovery < sizeof(hdr) || *recovery > tdb->map_size) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: invalid recovery offset %zu", (size_t)*recovery); return false; @@ -91,32 +95,36 @@ static bool check_hash_chain(struct tdb_context *tdb, void *private_data) { struct tdb_used_record rec; + enum TDB_ERROR ecode; - if (tdb_read_convert(tdb, off, &rec, sizeof(rec)) == -1) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (rec_magic(&rec) != TDB_CHAIN_MAGIC) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash chain magic %llu", (long long)rec_magic(&rec)); return false; } if (rec_data_length(&rec) != sizeof(struct tdb_chain)) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash chain length %llu vs %zu", (long long)rec_data_length(&rec), sizeof(struct tdb_chain)); return false; } if (rec_key_length(&rec) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash chain key length %llu", (long long)rec_key_length(&rec)); return false; } if (rec_hash(&rec) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash chain hash value %llu", (long long)rec_hash(&rec)); return false; @@ -128,8 +136,10 @@ static bool check_hash_chain(struct tdb_context *tdb, return false; off = tdb_read_off(tdb, off + offsetof(struct tdb_chain, next)); - if (off == TDB_OFF_ERR) + if (TDB_OFF_IS_ERR(off)) { + tdb->ecode = off; return false; + } if (off == 0) return true; (*num_found)++; @@ -148,23 +158,27 @@ static bool check_hash_record(struct tdb_context *tdb, void *private_data) { struct tdb_used_record rec; + enum TDB_ERROR ecode; if (hprefix_bits >= 64) return check_hash_chain(tdb, off, hprefix, used, num_used, num_found, check, private_data); - if (tdb_read_convert(tdb, off, &rec, sizeof(rec)) == -1) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (rec_magic(&rec) != TDB_HTABLE_MAGIC) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash table magic %llu", (long long)rec_magic(&rec)); return false; } if (rec_data_length(&rec) != sizeof(tdb_off_t) << TDB_SUBLEVEL_HASH_BITS) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash table length %llu vs %llu", (long long)rec_data_length(&rec), (long long)sizeof(tdb_off_t) @@ -172,13 +186,13 @@ static bool check_hash_record(struct tdb_context *tdb, return false; } if (rec_key_length(&rec) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash table key length %llu", (long long)rec_key_length(&rec)); return false; } if (rec_hash(&rec) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Bad hash table hash value %llu", (long long)rec_hash(&rec)); return false; @@ -219,13 +233,16 @@ static bool check_hash_tree(struct tdb_context *tdb, unsigned int g, b; const tdb_off_t *hash; struct tdb_used_record rec; + enum TDB_ERROR ecode; hash = tdb_access_read(tdb, off, 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); @@ -240,7 +257,7 @@ static bool check_hash_tree(struct tdb_context *tdb, p = asearch(&off, used, num_used, off_cmp); if (!p) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: Invalid offset %llu " "in hash", (long long)off); goto fail; @@ -253,7 +270,7 @@ static bool check_hash_tree(struct tdb_context *tdb, /* Chained entries are unordered. */ if (is_subhash(group[b])) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: Invalid chain" " entry subhash"); goto fail; @@ -261,7 +278,7 @@ static bool check_hash_tree(struct tdb_context *tdb, h = hash_record(tdb, off); if (h != hprefix) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "check: bad hash chain" " placement" " 0x%llx vs 0x%llx", @@ -269,9 +286,12 @@ static bool check_hash_tree(struct tdb_context *tdb, (long long)hprefix); goto fail; } - if (tdb_read_convert(tdb, off, &rec, - sizeof(rec))) + ecode = tdb_read_convert(tdb, off, &rec, + sizeof(rec)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; goto fail; + } goto check; } @@ -300,7 +320,7 @@ static bool check_hash_tree(struct tdb_context *tdb, if (get_bits(h, hprefix_bits, &used_bits) != hprefix && hprefix_bits) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "check: bad hash placement" " 0x%llx vs 0x%llx", (long long)h, (long long)hprefix); @@ -310,7 +330,7 @@ static bool check_hash_tree(struct tdb_context *tdb, /* Does it belong in this group? */ if (get_bits(h, group_bits, &used_bits) != g) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "check: bad group %llu vs %u", (long long)h, g); goto fail; @@ -322,7 +342,7 @@ static bool check_hash_tree(struct tdb_context *tdb, != bucket) { used_bits -= TDB_HASH_GROUP_BITS; tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "check: bad bucket %u vs %u", (unsigned)get_bits(h, TDB_HASH_GROUP_BITS, @@ -338,7 +358,7 @@ static bool check_hash_tree(struct tdb_context *tdb, i = (i + 1) % (1 << TDB_HASH_GROUP_BITS)) { if (group[i] == 0) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "check: bad group placement" " %u vs %u", b, bucket); @@ -346,13 +366,16 @@ static bool check_hash_tree(struct tdb_context *tdb, } } - if (tdb_read_convert(tdb, off, &rec, sizeof(rec))) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; goto fail; + } /* Bottom bits must match header. */ if ((h & ((1 << 11)-1)) != rec_hash(&rec)) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: Bad hash magic at" " offset %llu (0x%llx vs 0x%llx)", (long long)off, @@ -370,8 +393,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; @@ -403,7 +428,7 @@ static bool check_hash(struct tdb_context *tdb, return false; if (num_found != num_used) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Not all entries are in hash"); return false; } @@ -416,32 +441,38 @@ static bool check_free(struct tdb_context *tdb, tdb_off_t prev, unsigned int ftable, unsigned int bucket) { + enum TDB_ERROR ecode; + if (frec_magic(frec) != TDB_FREE_MAGIC) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: offset %llu bad magic 0x%llx", (long long)off, (long long)frec->magic_and_prev); return false; } if (frec_ftable(frec) != ftable) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: offset %llu bad freetable %u", (long long)off, frec_ftable(frec)); return false; } - if (tdb->methods->oob(tdb, off - + frec_len(frec) + sizeof(struct tdb_used_record), - false)) + ecode = tdb->methods->oob(tdb, off + + frec_len(frec) + + sizeof(struct tdb_used_record), + false); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (size_to_bucket(frec_len(frec)) != bucket) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: offset %llu in wrong bucket %u vs %u", (long long)off, bucket, size_to_bucket(frec_len(frec))); return false; } if (prev != frec_prev(frec)) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: offset %llu bad prev %llu vs %llu", (long long)off, (long long)prev, (long long)frec_len(frec)); @@ -460,15 +491,19 @@ static bool check_free_table(struct tdb_context *tdb, struct tdb_freetable ft; tdb_off_t h; unsigned int i; + enum TDB_ERROR ecode; - if (tdb_read_convert(tdb, ftable_off, &ft, sizeof(ft)) == -1) + ecode = tdb_read_convert(tdb, ftable_off, &ft, sizeof(ft)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (rec_magic(&ft.hdr) != TDB_FTABLE_MAGIC || rec_key_length(&ft.hdr) != 0 || rec_data_length(&ft.hdr) != sizeof(ft) - sizeof(ft.hdr) || rec_hash(&ft.hdr) != 0) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Invalid header on free table"); return false; } @@ -479,10 +514,15 @@ static bool check_free_table(struct tdb_context *tdb, h = bucket_off(ftable_off, i); for (off = tdb_read_off(tdb, h); off; off = f.next) { - if (off == TDB_OFF_ERR) + if (TDB_OFF_IS_ERR(off)) { + tdb->ecode = off; return false; - if (tdb_read_convert(tdb, off, &f, sizeof(f))) + } + ecode = tdb_read_convert(tdb, off, &f, sizeof(f)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (!check_free(tdb, off, &f, prev, ftable_num, i)) return false; @@ -490,7 +530,7 @@ static bool check_free_table(struct tdb_context *tdb, p = asearch(&off, fr, num_free, off_cmp); if (!p) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: Invalid offset" " %llu in free table", (long long)off); @@ -509,11 +549,15 @@ static bool check_free_table(struct tdb_context *tdb, size_t dead_space(struct tdb_context *tdb, tdb_off_t off) { size_t len; + enum TDB_ERROR ecode; for (len = 0; off + len < tdb->map_size; len++) { char c; - if (tdb->methods->tread(tdb, off, &c, 1)) + ecode = tdb->methods->tread(tdb, off, &c, 1); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return 0; + } if (c != 0 && c != 0x43) break; } @@ -527,6 +571,7 @@ static bool check_linear(struct tdb_context *tdb, { tdb_off_t off; tdb_len_t len; + enum TDB_ERROR ecode; bool found_recovery = false; for (off = sizeof(struct tdb_header); off < tdb->map_size; off += len) { @@ -536,15 +581,20 @@ static bool check_linear(struct tdb_context *tdb, struct tdb_recovery_record r; } rec; /* r is larger: only get that if we need to. */ - if (tdb_read_convert(tdb, off, &rec, sizeof(rec.f)) == -1) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.f)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } /* If we crash after ftruncate, we can get zeroes or fill. */ if (rec.r.magic == TDB_RECOVERY_INVALID_MAGIC || rec.r.magic == 0x4343434343434343ULL) { - if (tdb_read_convert(tdb, off, &rec, sizeof(rec.r))) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; - + } if (recovery == off) { found_recovery = true; len = sizeof(rec.r) + rec.r.max_len; @@ -552,24 +602,27 @@ static bool check_linear(struct tdb_context *tdb, len = dead_space(tdb, off); if (len < sizeof(rec.r)) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: invalid dead" " space at %zu", (size_t)off); return false; } - tdb_logerr(tdb, TDB_SUCCESS, TDB_DEBUG_WARNING, + tdb_logerr(tdb, TDB_SUCCESS, TDB_LOG_WARNING, "Dead space at %zu-%zu (of %zu)", (size_t)off, (size_t)(off + len), (size_t)tdb->map_size); } } else if (rec.r.magic == TDB_RECOVERY_MAGIC) { - if (tdb_read_convert(tdb, off, &rec, sizeof(rec.r))) + ecode = tdb_read_convert(tdb, off, &rec, sizeof(rec.r)); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return false; + } if (recovery != off) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: unexpected recovery" " record at offset %zu", (size_t)off); @@ -577,14 +630,14 @@ static bool check_linear(struct tdb_context *tdb, } if (rec.r.len > rec.r.max_len) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: invalid recovery length" " %zu", (size_t)rec.r.len); return false; } if (rec.r.eof > tdb->map_size) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: invalid old EOF" " %zu", (size_t)rec.r.eof); return false; @@ -595,7 +648,7 @@ static bool check_linear(struct tdb_context *tdb, len = sizeof(rec.u) + frec_len(&rec.f); if (off + len > tdb->map_size) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: free overlength %llu" " at offset %llu", (long long)len, (long long)off); @@ -605,7 +658,7 @@ static bool check_linear(struct tdb_context *tdb, if (frec_ftable(&rec.f) != TDB_FTABLE_NONE && !append(fr, num_free, off)) { tdb_logerr(tdb, TDB_ERR_OOM, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: tracking %zu'th" " free record.", *num_free); return false; @@ -619,7 +672,7 @@ static bool check_linear(struct tdb_context *tdb, /* This record is used! */ if (!append(used, num_used, off)) { tdb_logerr(tdb, TDB_ERR_OOM, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: tracking %zu'th" " used record.", *num_used); return false; @@ -632,7 +685,7 @@ static bool check_linear(struct tdb_context *tdb, len = sizeof(rec.u) + klen + dlen + extra; if (off + len > tdb->map_size) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: used overlength %llu" " at offset %llu", (long long)len, (long long)off); @@ -641,7 +694,7 @@ static bool check_linear(struct tdb_context *tdb, if (len < sizeof(rec.f)) { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: too short record %llu" " at %llu", (long long)len, (long long)off); @@ -649,7 +702,7 @@ static bool check_linear(struct tdb_context *tdb, } } else { tdb_logerr(tdb, TDB_ERR_CORRUPT, - TDB_DEBUG_ERROR, + TDB_LOG_ERROR, "tdb_check: Bad magic 0x%llx at offset %zu", (long long)rec_magic(&rec.u), (size_t)off); return false; @@ -658,7 +711,7 @@ static bool check_linear(struct tdb_context *tdb, /* We must have found recovery area if there was one. */ if (recovery != 0 && !found_recovery) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: expected a recovery area at %zu", (size_t)recovery); return false; @@ -673,11 +726,17 @@ int tdb_check(struct tdb_context *tdb, { tdb_off_t *fr = NULL, *used = NULL, ft, recovery; size_t num_free = 0, num_used = 0, num_found = 0, num_ftables = 0; + enum TDB_ERROR ecode; - if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false) != 0) + ecode = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; return -1; + } - if (tdb_lock_expand(tdb, F_RDLCK) != 0) { + ecode = tdb_lock_expand(tdb, F_RDLCK); + if (ecode != TDB_SUCCESS) { + tdb->ecode = ecode; tdb_allrecord_unlock(tdb, F_RDLCK); return -1; } @@ -690,8 +749,10 @@ int tdb_check(struct tdb_context *tdb, goto fail; for (ft = first_ftable(tdb); ft; ft = next_ftable(tdb, ft)) { - if (ft == TDB_OFF_ERR) + if (TDB_OFF_IS_ERR(ft)) { + tdb->ecode = ft; goto fail; + } if (!check_free_table(tdb, ft, num_ftables, fr, num_free, &num_found)) goto fail; @@ -703,7 +764,7 @@ int tdb_check(struct tdb_context *tdb, goto fail; if (num_found != num_free) { - tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_DEBUG_ERROR, + tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR, "tdb_check: Not all entries are in free table"); return -1; }