diff --git a/include/aaruformat/context.h b/include/aaruformat/context.h index 3080c4a..b0b078c 100644 --- a/include/aaruformat/context.h +++ b/include/aaruformat/context.h @@ -400,6 +400,12 @@ typedef struct aaruformat_context uint16_t ec_meta_M; ///< M for metadata group. uint32_t ec_meta_shard_size; ///< Shard size for metadata group. void *ec_meta_block_lookup; ///< uthash: block file offset → stripe index + position (metadata group). + void *ec_ddt_stripes; ///< Parsed EcReadStripe array for DDT-secondary group. + uint32_t ec_ddt_stripe_count; ///< Number of DDT-secondary stripes. + uint16_t ec_ddt_K; ///< K for DDT-secondary group. + uint16_t ec_ddt_M; ///< M for DDT-secondary group. + uint32_t ec_ddt_shard_size; ///< Shard size for DDT-secondary group. + void *ec_ddt_block_lookup; ///< uthash: block file offset → stripe index + position (DDT group). bool ec_recovery_available; ///< True if ECMB loaded and recovery is possible. bool ec_recovery_in_progress; ///< Recursion guard for recovery (prevents infinite loops). } aaruformat_context; diff --git a/include/erasure_internal.h b/include/erasure_internal.h index 067be29..c90a8e1 100644 --- a/include/erasure_internal.h +++ b/include/erasure_internal.h @@ -90,6 +90,12 @@ int32_t ec_recover_raw_block(aaruformat_context *ctx, uint64_t block_offset, int32_t ec_recover_meta_block(aaruformat_context *ctx, uint64_t block_offset, uint8_t **recovered_data, uint32_t *recovered_size); +/** + * @brief Attempt to recover a DDT secondary block at a given file offset. + */ +int32_t ec_recover_ddt_block(aaruformat_context *ctx, uint64_t block_offset, + uint8_t **recovered_data, uint32_t *recovered_size); + /* ---- Cleanup ---- */ void ec_free(aaruformat_context *ctx); diff --git a/src/ddt/ddt_v2.c b/src/ddt/ddt_v2.c index f1500c1..102615c 100644 --- a/src/ddt/ddt_v2.c +++ b/src/ddt/ddt_v2.c @@ -22,6 +22,7 @@ #include #include "aaruformat.h" +#include "erasure_internal.h" #include "internal.h" #include "log.h" @@ -674,7 +675,75 @@ int32_t decode_ddt_entry_v2(aaruformat_context *ctx, const uint64_t sector_addre } if(ctx->user_data_ddt_header.tableShift > 0) - return decode_ddt_multi_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status); + { + int32_t result = decode_ddt_multi_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status); + + /* If secondary DDT load failed, attempt EC recovery */ + if(result != AARUF_STATUS_OK && ctx->ec_recovery_available && !ctx->ec_recovery_in_progress) + { + /* Compute which secondary DDT failed */ + uint64_t sa = negative ? ctx->user_data_ddt_header.negative - sector_address + : sector_address + ctx->user_data_ddt_header.negative; + int items = 1 << ctx->user_data_ddt_header.tableShift; + uint64_t pos = sa / items; + uint64_t ddt_off = ctx->user_data_ddt2[pos]; + ddt_off *= 1 << ctx->user_data_ddt_header.blockAlignmentShift; + + TRACE("Attempting EC recovery for DDT secondary at offset %" PRIu64, ddt_off); + uint8_t *recovered = NULL; + uint32_t rec_size = 0; + if(ec_recover_ddt_block(ctx, ddt_off, &recovered, &rec_size) == AARUF_STATUS_OK && recovered) + { + /* Parse DdtHeader2 from recovered bytes, decompress, load into cache */ + if(rec_size >= sizeof(DdtHeader2)) + { + DdtHeader2 rec_hdr; + memcpy(&rec_hdr, recovered, sizeof(DdtHeader2)); + + uint8_t *payload = recovered + sizeof(DdtHeader2); + uint32_t payload_size = rec_size - sizeof(DdtHeader2); + uint8_t *ddt_data = NULL; + + if(rec_hdr.compression == kCompressionNone && payload_size >= rec_hdr.length) + { + ddt_data = (uint8_t *)malloc((size_t)rec_hdr.length); + if(ddt_data) memcpy(ddt_data, payload, (size_t)rec_hdr.length); + } + else if(rec_hdr.compression == kCompressionLzma && payload_size > LZMA_PROPERTIES_LENGTH) + { + ddt_data = (uint8_t *)malloc((size_t)rec_hdr.length); + if(ddt_data) + { + size_t out_sz = (size_t)rec_hdr.length; + size_t src_sz = payload_size - LZMA_PROPERTIES_LENGTH; + aaruf_lzma_decode_buffer(ddt_data, &out_sz, payload + LZMA_PROPERTIES_LENGTH, + &src_sz, payload, LZMA_PROPERTIES_LENGTH); + } + } + else if(rec_hdr.compression == kCompressionZstd && payload_size > 0) + { + ddt_data = (uint8_t *)malloc((size_t)rec_hdr.length); + if(ddt_data) + aaruf_zstd_decode_buffer(ddt_data, (size_t)rec_hdr.length, payload, payload_size); + } + + if(ddt_data) + { + TRACE("EC recovery succeeded for DDT secondary, loading into cache"); + free(ctx->cached_secondary_ddt2); + ctx->cached_secondary_ddt2 = (uint64_t *)ddt_data; + ctx->cached_ddt_offset = ddt_off; + /* Retry the decode */ + result = decode_ddt_multi_level_v2(ctx, sector_address, negative, + offset, block_offset, sector_status); + } + } + free(recovered); + } + } + + return result; + } return decode_ddt_single_level_v2(ctx, sector_address, negative, offset, block_offset, sector_status); } diff --git a/src/erasure.c b/src/erasure.c index cdd81cb..67ede3f 100644 --- a/src/erasure.c +++ b/src/erasure.c @@ -912,6 +912,15 @@ int32_t ec_recover_meta_block(aaruformat_context *ctx, uint64_t block_offset, ctx->ec_meta_K, ctx->ec_meta_M, ctx->ec_meta_shard_size); } +int32_t ec_recover_ddt_block(aaruformat_context *ctx, uint64_t block_offset, + uint8_t **recovered_data, uint32_t *recovered_size) +{ + if(!ctx->ec_ddt_stripes || ctx->ec_ddt_stripe_count == 0) return AARUF_ERROR_CANNOT_READ_BLOCK; + return ec_recover_raw_block(ctx, block_offset, recovered_data, recovered_size, + ctx->ec_ddt_stripes, ctx->ec_ddt_stripe_count, ctx->ec_ddt_block_lookup, + ctx->ec_ddt_K, ctx->ec_ddt_M, ctx->ec_ddt_shard_size); +} + /** * @brief Free all erasure coding state from the context. * @@ -995,14 +1004,32 @@ void ec_free(aaruformat_context *ctx) { EcBlockLookupEntry *root = (EcBlockLookupEntry *)ctx->ec_meta_block_lookup; EcBlockLookupEntry *entry, *tmp; - HASH_ITER(hh, root, entry, tmp) - { - HASH_DEL(root, entry); - free(entry); - } + HASH_ITER(hh, root, entry, tmp) { HASH_DEL(root, entry); free(entry); } ctx->ec_meta_block_lookup = NULL; } + /* Free DDT-secondary group read-path state */ + if(ctx->ec_ddt_stripes) + { + EcReadStripe *stripes = (EcReadStripe *)ctx->ec_ddt_stripes; + for(uint32_t i = 0; i < ctx->ec_ddt_stripe_count; i++) + { + free(stripes[i].data_entries); + free(stripes[i].parity_offsets); + } + free(stripes); + ctx->ec_ddt_stripes = NULL; + } + ctx->ec_ddt_stripe_count = 0; + + if(ctx->ec_ddt_block_lookup) + { + EcBlockLookupEntry *root = (EcBlockLookupEntry *)ctx->ec_ddt_block_lookup; + EcBlockLookupEntry *entry, *tmp; + HASH_ITER(hh, root, entry, tmp) { HASH_DEL(root, entry); free(entry); } + ctx->ec_ddt_block_lookup = NULL; + } + ctx->ec_recovery_available = false; } @@ -1178,6 +1205,33 @@ void ec_load_ecmb(aaruformat_context *ctx) data_stripes = grp_stripes; data_stripe_count = group.stripeCount; } + else if(group.groupType == kECGroupDdtSecondary) + { + /* Store DDT-secondary group for recovery of secondary DDT subtables */ + EcBlockLookupEntry *ddt_lookup_root = (EcBlockLookupEntry *)ctx->ec_ddt_block_lookup; + if(grp_stripes) + { + for(uint32_t s = 0; s < group.stripeCount; s++) + { + if(!grp_stripes[s].data_entries) continue; + for(uint16_t k = 0; k < grp_stripes[s].actual_k; k++) + { + EcBlockLookupEntry *le = (EcBlockLookupEntry *)calloc(1, sizeof(EcBlockLookupEntry)); + if(!le) break; + le->block_offset = grp_stripes[s].data_entries[k].offset; + le->stripe_index = s; + le->position = k; + HASH_ADD(hh, ddt_lookup_root, block_offset, sizeof(uint64_t), le); + } + } + } + ctx->ec_ddt_stripes = grp_stripes; + ctx->ec_ddt_stripe_count = group.stripeCount; + ctx->ec_ddt_K = group.K; + ctx->ec_ddt_M = group.M; + ctx->ec_ddt_shard_size = group.shardSize; + ctx->ec_ddt_block_lookup = ddt_lookup_root; + } else if(group.groupType == kECGroupMetadata) { /* Store metadata group for recovery of media tags, tracks, checksums, etc. */