mirror of
https://github.com/aaru-dps/libaaruformat.git
synced 2026-11-17 17:50:48 +00:00
Do EC recovery on secondary level DDT2 reading.
This commit is contained in:
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -22,6 +22,7 @@
|
||||
#include <stdlib.h>
|
||||
|
||||
#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);
|
||||
}
|
||||
|
||||
@@ -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. */
|
||||
|
||||
Reference in New Issue
Block a user