86 lines
2.7 KiB
Python
86 lines
2.7 KiB
Python
import struct
|
|
|
|
CHUNK = 128*512
|
|
LV_START = 5120000*512
|
|
BSIZE = 4096
|
|
BPG = 32768
|
|
GDT_ENTRY = 64
|
|
NUM_GROUPS = 35728
|
|
|
|
def is_meta(virt_byte):
|
|
in_group = virt_byte % (5*CHUNK)
|
|
return (in_group // CHUNK) == 4
|
|
|
|
def raw_read(virt_offset, length):
|
|
result = bytearray(length)
|
|
pos = virt_offset
|
|
remaining = length
|
|
with open('/dev/md0','rb') as f:
|
|
while remaining > 0:
|
|
group = pos // (5*CHUNK)
|
|
in_group = pos % (5*CHUNK)
|
|
chunk_idx = in_group // CHUNK
|
|
intra = in_group % CHUNK
|
|
seg_len = min(CHUNK-intra, remaining)
|
|
dst_off = pos - virt_offset
|
|
if chunk_idx != 4:
|
|
phys = LV_START + group*4*CHUNK + chunk_idx*CHUNK + intra
|
|
f.seek(phys)
|
|
data = f.read(seg_len)
|
|
result[dst_off:dst_off+len(data)] = data
|
|
pos += seg_len
|
|
remaining -= seg_len
|
|
return bytes(result)
|
|
|
|
# Build merged GDT: for each group, use whichever of primary/backup
|
|
# is NOT in a metadata chunk
|
|
print('Building merged GDT...')
|
|
primary_start = BSIZE # block 1
|
|
backup_start = (1*BPG + 1) * BSIZE # group 1 backup
|
|
|
|
# Read both GDTs in full
|
|
primary_gdt = raw_read(primary_start, NUM_GROUPS * GDT_ENTRY)
|
|
backup_gdt = raw_read(backup_start, NUM_GROUPS * GDT_ENTRY)
|
|
|
|
merged = bytearray(NUM_GROUPS * GDT_ENTRY)
|
|
primary_used = 0
|
|
backup_used = 0
|
|
neither = 0
|
|
|
|
for g in range(NUM_GROUPS):
|
|
prim_byte = primary_start + g * GDT_ENTRY
|
|
backup_byte = backup_start + g * GDT_ENTRY
|
|
src_off = g * GDT_ENTRY
|
|
|
|
if not is_meta(prim_byte):
|
|
# Primary is valid - use it
|
|
merged[src_off:src_off+GDT_ENTRY] = primary_gdt[src_off:src_off+GDT_ENTRY]
|
|
primary_used += 1
|
|
elif not is_meta(backup_byte):
|
|
# Primary is in metadata chunk - use backup
|
|
merged[src_off:src_off+GDT_ENTRY] = backup_gdt[src_off:src_off+GDT_ENTRY]
|
|
backup_used += 1
|
|
else:
|
|
# Both bad - shouldn't happen given our analysis
|
|
neither += 1
|
|
|
|
print(f'From primary GDT: {primary_used}')
|
|
print(f'From backup GDT: {backup_used}')
|
|
print(f'Neither (error): {neither}')
|
|
assert neither == 0, 'Unexpected gap in coverage!'
|
|
|
|
# Verify merged GDT looks sane
|
|
print()
|
|
print('Sample entries:')
|
|
for g in [0, 1, 100, 1000, 32699, 35000, 35727]:
|
|
e = merged[g*GDT_ENTRY:(g+1)*GDT_ENTRY]
|
|
bb = struct.unpack_from('<I',e,0)[0]
|
|
ib = struct.unpack_from('<I',e,4)[0]
|
|
it = struct.unpack_from('<I',e,8)[0]
|
|
cs = struct.unpack_from('<H',e,30)[0]
|
|
print(f' Group {g:6d}: bb={bb:8d} ib={ib:8d} it={it:10d} csum=0x{cs:04x}')
|
|
|
|
with open('/tmp/merged_gdt.bin','wb') as f:
|
|
f.write(merged)
|
|
print(f'Saved /tmp/merged_gdt.bin ({len(merged)//1024}KB)')
|