xfs_inode.cpp

Go to the documentation of this file.

// xfs_inode.cpp -- dinode core + extent record decoder.
//
// All multi-byte fields on disk are big-endian. Extent records are
// further bit-packed across two 64-bit words; see the comment block in
// xfs_inode.hpp for the layout. The decoder is unit-tested -- this is
// the part that is most sensitive to subtle off-by-one mistakes (the
// "9 high + 43 low" split of the physical block was the trickiest bit).
 
#include "xfs_inode.hpp"
 
#include <algorithm>
 
namespace xfs {
 
bool parse_dinode_core(const unsigned char* buf, DinodeCore& out) {
    if (buf == nullptr) return false;
    out = {};
 
    out.magic = be16(buf + 0x00);
    if (out.magic != XFS_DINODE_MAGIC_BE) return false;
 
    out.mode    = be16(buf + 0x02);
    out.version = buf[0x04];
    out.format  = buf[0x05];
 
    // Sanity: version must be 1, 2, or 3
    if (out.version < 1 || out.version > 3) return false;
    // Sanity: format must be 0..4 (we only USE 1,2,3 but accept the others)
    if (out.format > 4) return false;
 
    out.uid     = be32(buf + 0x08);
    out.gid     = be32(buf + 0x0C);
    out.nlink   = be32(buf + 0x10);
 
    out.size    = static_cast<int64_t>(be64(buf + 0x3C));
    out.nblocks = be64(buf + 0x44);
 
    out.nextents  = be32(buf + 0x50);
    out.anextents = be16(buf + 0x54);
    out.forkoff   = buf[0x56];
    out.aformat   = buf[0x57];
    out.flags     = be16(buf + 0x5E);
    out.gen       = be32(buf + 0x60);
 
    if (out.is_v3()) {
        // V3 extension fields
        out.flags2 = be64(buf + 0x7C);
        out.ino    = be64(buf + 0x9C);
    }
 
    // Sanity: refuse impossibly-large extent counts (corrupt inode).
    // 1 million extents in a single fork is already absurd.
    if (out.nextents > 1'000'000) return false;
 
    return true;
}
 
uint32_t dinode_data_fork_length(const DinodeCore& core, uint32_t inode_size) {
    const uint32_t fork_start = dinode_data_fork_offset(core);
    if (fork_start >= inode_size) return 0;
 
    // If forkoff != 0, the attribute fork begins at:
    //    fork_start + forkoff * 8 bytes
    // ...so the data fork has that many bytes available.
    if (core.forkoff != 0) {
        const uint32_t data_len = static_cast<uint32_t>(core.forkoff) * 8u;
        // Defensive cap: never exceed inode_size - fork_start
        const uint32_t max_avail = inode_size - fork_start;
        return std::min(data_len, max_avail);
    }
    return inode_size - fork_start;
}
 
void decode_extent_record(const unsigned char* buf16, Extent& out) {
    const uint64_t w0 = be64(buf16 + 0);
    const uint64_t w1 = be64(buf16 + 8);
 
    // Bit 63 of w0: flag (unwritten)
    out.unwritten = ((w0 >> 63) & 1ull) != 0;
 
    // Bits 62..9 of w0: logical offset (54 bits)
    const uint64_t logical_mask = (1ull << 54) - 1ull;
    out.logical_off_blocks = (w0 >> 9) & logical_mask;
 
    // Bits 8..0 of w0: high 9 bits of physical block
    const uint64_t phys_high9 = w0 & 0x1FFull;
    // Bits 63..21 of w1: low 43 bits of physical block
    const uint64_t phys_low43 = (w1 >> 21) & ((1ull << 43) - 1ull);
    out.physical_block = (phys_high9 << 43) | phys_low43;
 
    // Bits 20..0 of w1: length (21 bits)
    out.length_blocks = static_cast<uint32_t>(w1 & ((1ull << 21) - 1ull));
}
 
uint64_t fsb_to_disk_offset(uint64_t fsb, const VolumeContext& vol) {
    if (vol.sb.agblklog == 0) return vol.volume_offset + fsb * vol.sb.blocksize;
    const uint64_t mask = (1ull << vol.sb.agblklog) - 1ull;
    const uint32_t agno = static_cast<uint32_t>(fsb >> vol.sb.agblklog);
    const uint32_t agbno = static_cast<uint32_t>(fsb & mask);
    return vol.volume_offset
         + static_cast<uint64_t>(agno) * vol.sb.agblocks * vol.sb.blocksize
         + static_cast<uint64_t>(agbno) * vol.sb.blocksize;
}
 
bool decode_extents_inline(const unsigned char* data_fork_buf,
                           uint32_t nextents,
                           uint32_t max_bytes,
                           std::vector<Extent>& out) {
    if (data_fork_buf == nullptr) return false;
    if (static_cast<uint64_t>(nextents) * 16ull > max_bytes) {
        return false;
    }
    out.clear();
    out.reserve(nextents);
    for (uint32_t i = 0; i < nextents; ++i) {
        Extent e;
        decode_extent_record(data_fork_buf + i * 16, e);
        // Sanity: a length of 0 is impossible
        if (e.length_blocks == 0) {
            // Be tolerant: skip and continue rather than abort.
            continue;
        }
        out.push_back(e);
    }
    return true;
}
 
} // namespace xfs