xfs_format.cpp

Go to the documentation of this file.

// xfs_format.cpp -- on-disk parsers for XFS structures.
//
// All parsers are pure functions: they read from a byte buffer of the
// expected size and fill in the destination struct. They do NOT perform
// I/O. They DO perform basic sanity checks and return false on malformed
// data (e.g. wrong magic, impossible field combinations).
//
// CRC validation is intentionally skipped here; for read-only recovery
// from possibly-damaged disks we want to extract data even when CRCs are
// bad. A separate function can verify CRCs later if the UI wants to flag
// degraded reads.
 
#include "xfs_format.hpp"
 
#include <algorithm>
 
namespace xfs {
 
bool parse_superblock(const unsigned char* buf, Superblock& out) {
    if (buf == nullptr) return false;
 
    out.magicnum = be32(buf + 0x00);
    if (out.magicnum != XFS_SB_MAGIC) {
        return false;
    }
 
    out.blocksize  = be32(buf + 0x04);
    out.dblocks    = be64(buf + 0x08);
    out.rblocks    = be64(buf + 0x10);
    out.rextents   = be64(buf + 0x18);
    std::copy(buf + 0x20, buf + 0x30, out.uuid.begin());
    out.logstart   = be64(buf + 0x30);
    out.rootino    = be64(buf + 0x38);
    out.rbmino     = be64(buf + 0x40);
    out.rsumino    = be64(buf + 0x48);
    out.rextsize   = be32(buf + 0x50);
    out.agblocks   = be32(buf + 0x54);
    out.agcount    = be32(buf + 0x58);
    out.rbmblocks  = be32(buf + 0x5C);
    out.logblocks  = be32(buf + 0x60);
    out.versionnum = be16(buf + 0x64);
    out.sectsize   = be16(buf + 0x66);
    out.inodesize  = be16(buf + 0x68);
    out.inopblock  = be16(buf + 0x6A);
    std::copy(buf + 0x6C, buf + 0x78, out.fname.begin());
    out.blocklog   = buf[0x78];
    out.sectlog    = buf[0x79];
    out.inodelog   = buf[0x7A];
    out.inopblog   = buf[0x7B];
    out.agblklog   = buf[0x7C];
    out.rextslog   = buf[0x7D];
    out.inprogress = buf[0x7E];
    out.imax_pct   = buf[0x7F];
    out.icount     = be64(buf + 0x80);
    out.ifree      = be64(buf + 0x88);
    out.fdblocks   = be64(buf + 0x90);
    out.frextents  = be64(buf + 0x98);
    out.uquotino   = be64(buf + 0xA0);
    out.gquotino   = be64(buf + 0xA8);
    out.qflags     = be16(buf + 0xB0);
    out.flags      = buf[0xB2];
    out.shared_vn  = buf[0xB3];
    out.inoalignmt = be32(buf + 0xB4);
    out.unit       = be32(buf + 0xB8);
    out.width      = be32(buf + 0xBC);
    out.dirblklog  = buf[0xC0];
    out.logsectlog = buf[0xC1];
    out.logsectsize= be16(buf + 0xC2);
    out.logsunit   = be32(buf + 0xC4);
    out.features2  = be32(buf + 0xC8);
 
    // V5-only fields. Read them anyway (cheap), but they're only meaningful
    // if format_version()==5. The V4 superblock zeroes these bytes (mkfs
    // wipes the whole sector before writing).
    out.bad_features2          = be32(buf + 0xCC);
    out.features_compat        = be32(buf + 0xD0);
    out.features_ro_compat     = be32(buf + 0xD4);
    out.features_incompat      = be32(buf + 0xD8);
    out.features_log_incompat  = be32(buf + 0xDC);
    out.crc                    = be32(buf + 0xE0);
    out.spino_align            = be32(buf + 0xE4);
    out.pquotino               = be64(buf + 0xE8);
    out.lsn                    = be64(buf + 0xF0);
    std::copy(buf + 0xF8, buf + 0x108, out.meta_uuid.begin());
 
    // ---- Sanity checks ----
 
    // blocksize must be a power of 2 in [512, 65536]
    if (out.blocksize < 512 || out.blocksize > 65536 ||
        (out.blocksize & (out.blocksize - 1)) != 0) {
        return false;
    }
    // sectsize must be a power of 2 in [256, 32768] and <= blocksize
    if (out.sectsize < 256 || out.sectsize > 32768 ||
        (out.sectsize & (out.sectsize - 1)) != 0 ||
        out.sectsize > out.blocksize) {
        return false;
    }
    // inodesize must be a power of 2 in [256, 2048] and <= blocksize
    if (out.inodesize < 256 || out.inodesize > 2048 ||
        (out.inodesize & (out.inodesize - 1)) != 0 ||
        out.inodesize > out.blocksize) {
        return false;
    }
    // log2 fields must agree with the explicit values
    if ((1u << out.blocklog) != out.blocksize ||
        (1u << out.sectlog)  != out.sectsize  ||
        (1u << out.inodelog) != out.inodesize) {
        return false;
    }
    if (out.inopblock == 0 || (1u << out.inopblog) != out.inopblock) {
        return false;
    }
    // agblocks/agcount must be plausible
    if (out.agblocks == 0 || out.agcount == 0) {
        return false;
    }
    // dblocks must be at least one AG worth
    if (out.dblocks < out.agblocks) {
        return false;
    }
    // version must be 4 or 5
    const unsigned ver = out.format_version();
    if (ver != XFS_SB_VERSION_4 && ver != XFS_SB_VERSION_5) {
        return false;
    }
    return true;
}
 
bool parse_agf(const unsigned char* buf, AGF& out) {
    if (buf == nullptr) return false;
 
    out.magicnum   = be32(buf + 0x00);
    if (out.magicnum != XFS_AGF_MAGIC_V4) { // V4/V5 share the same ASCII "XAGF"
        return false;
    }
    out.versionnum = be32(buf + 0x04);
    out.seqno      = be32(buf + 0x08);
    out.length     = be32(buf + 0x0C);
    out.roots[0]   = be32(buf + 0x10);
    out.roots[1]   = be32(buf + 0x14);
    out.roots[2]   = be32(buf + 0x18); // V5 rmap root; on V4 this is reserved/zero
    out.levels[0]  = be32(buf + 0x1C);
    out.levels[1]  = be32(buf + 0x20);
    out.levels[2]  = be32(buf + 0x24);
    out.flfirst    = be32(buf + 0x28);
    out.fllast     = be32(buf + 0x2C);
    out.flcount    = be32(buf + 0x30);
    out.freeblks   = be32(buf + 0x34);
    out.longest    = be32(buf + 0x38);
    out.btreeblks  = be32(buf + 0x3C);
 
    if (out.versionnum == 0 || out.length == 0) return false;
    if (out.levels[0] > 16 || out.levels[1] > 16) return false; // sanity
    return true;
}
 
bool parse_agi(const unsigned char* buf, AGI& out) {
    return parse_agi(buf, /*is_v5=*/false, out);
}
 
bool parse_agi(const unsigned char* buf, bool is_v5, AGI& out) {
    if (buf == nullptr) return false;
 
    out.magicnum   = be32(buf + 0x00);
    if (out.magicnum != XFS_AGI_MAGIC_V4) { // same magic on V4/V5
        return false;
    }
    out.versionnum = be32(buf + 0x04);
    out.seqno      = be32(buf + 0x08);
    out.length     = be32(buf + 0x0C);
    out.count      = be32(buf + 0x10);
    out.root       = be32(buf + 0x14);
    out.level      = be32(buf + 0x18);
    out.freecount  = be32(buf + 0x1C);
    out.newino     = be32(buf + 0x20);
    out.dirino     = be32(buf + 0x24);
    for (int i = 0; i < 64; ++i) {
        out.unlinked[i] = be32(buf + 0x28 + i * 4);
    }
 
    // V5-only fields: agi_free_root / agi_free_level (FINOBT roots).
    //
    // V5 AGI layout after unlinked[64] (offset 0x128):
    //   0x128 uuid_t agi_uuid              (16 bytes)
    //   0x138 __be32 agi_crc
    //   0x13C __be32 agi_pad32
    //   0x140 __be64 agi_lsn
    //   0x148 __be32 agi_free_root
    //   0x14C __be32 agi_free_level
    //
    // On V4 these bytes are not present (AGI is 296 bytes), so we leave
    // free_root/free_level at zero unless is_v5 is true.
    if (is_v5) {
        out.free_root  = be32(buf + 0x148);
        out.free_level = be32(buf + 0x14C);
    } else {
        out.free_root  = 0;
        out.free_level = 0;
    }
 
    if (out.versionnum == 0 || out.length == 0) return false;
    if (out.level > 16) return false;
    if (out.free_level > 16) return false;
    return true;
}
 
InodeAddress crack_inode(uint64_t ino, const Superblock& sb) {
    InodeAddress a;
    const unsigned agno_shift = sb.agblklog + sb.inopblog;
    const unsigned agbno_shift = sb.inopblog;
    const uint64_t inopblock_mask = static_cast<uint64_t>(sb.inopblock) - 1;
 
    a.agno   = static_cast<uint32_t>(ino >> agno_shift);
    a.agbno  = static_cast<uint32_t>((ino >> agbno_shift) & ((1u << sb.agblklog) - 1));
    a.offset = static_cast<uint32_t>(ino & inopblock_mask);
    return a;
}
 
} // namespace xfs