anonymous_namespace{xfs_recovery.cpp} Namespace Reference

Functions
bool	read_exact (DiskReader &reader, uint64_t off, void *dst, size_t n)
bool	validate_geometry (DiskReader &reader, uint64_t volume_offset, const xfs::Superblock &sb, std::string &err)
void	load_ag_headers (DiskReader &reader, uint64_t volume_offset, const xfs::Superblock &sb, uint32_t agno, xfs::AGContext &ag, std::vector< std::string > &logs)
bool	read_dinode (DiskReader &reader, const xfs::VolumeContext &vol, uint64_t ino, std::vector< unsigned char > &buf)
bool	write_extents_to_path (DiskReader &reader, const xfs::VolumeContext &vol, std::vector< xfs::Extent > extents, uint64_t file_size, const fs::path &out_path, std::string &err)
bool	collect_extents (DiskReader &reader, const xfs::VolumeContext &vol, const xfs::DinodeCore &core, const unsigned char *fork_data, uint32_t fork_len, uint32_t max_extents, std::vector< xfs::Extent > &out, std::vector< std::string > &logs, std::string &err)
bool	read_extents_data (DiskReader &reader, const xfs::VolumeContext &vol, const std::vector< xfs::Extent > &extents, uint64_t file_size, std::vector< unsigned char > &out, std::string &err)
bool	collect_dir_entries_block_or_leaf (DiskReader &reader, const xfs::VolumeContext &vol, const std::vector< xfs::Extent > &extents, bool has_ftype, std::vector< xfs::DirEntry > &out, std::vector< std::string > &logs)

Variables
constexpr uint64_t	XFS_DIR2_LEAF_OFFSET_BLOCKS = 32ull * 1024ull * 1024ull * 1024ull / 4096ull

Function Documentation

collect_dir_entries_block_or_leaf()

bool anonymous_namespace{xfs_recovery.cpp}::collect_dir_entries_block_or_leaf	(	DiskReader &	reader,
		const xfs::VolumeContext &	vol,
		const std::vector< xfs::Extent > &	extents,
		bool	has_ftype,
		std::vector< xfs::DirEntry > &	out,
		std::vector< std::string > &	logs )

Definition at line 348 of file xfs_recovery.cpp.

                                                                    {
    const uint64_t bsize = vol.sb.blocksize;
    const bool is_v5 = vol.sb.is_v5();
 
    // Compute the leaf cutoff in this volume's block units. The XFS
    // address-space convention reserves logical offset 32 GiB for the
    // leaf/node area; in volume blocks that's (32 GiB / blocksize).
    const uint64_t leaf_cutoff_blocks = (32ull * 1024ull * 1024ull * 1024ull) / bsize;
 
    bool any_block_magic_seen = false;
    bool any_data_magic_seen = false;
 
    for (const auto& ext : extents) {
        if (ext.unwritten) continue;
        // Skip extents in the leaf/freespace/btree area (logical >= cutoff)
        if (ext.logical_off_blocks >= leaf_cutoff_blocks) continue;
 
        const uint32_t take_blocks = static_cast<uint32_t>(std::min<uint64_t>(
            ext.length_blocks,
            leaf_cutoff_blocks - ext.logical_off_blocks));
 
        for (uint32_t b = 0; b < take_blocks; ++b) {
            const uint64_t phys_byte =
                xfs::fsb_to_disk_offset(ext.physical_block + b, vol);
            std::vector<unsigned char> blk(bsize, 0);
            if (!reader.read_at(phys_byte, blk.data(), bsize)) {
                logs.push_back("XFS dir: read failed at FSB " +
                               std::to_string(ext.physical_block + b));
                continue;
            }
 
            // First, try BLOCK magic (single-block dir); on miss, try DATA.
            // Most multi-block dirs will be DATA; single-block will be BLOCK.
            std::vector<xfs::DirEntry> entries;
            bool parsed = xfs::parse_dir_data_block(blk.data(), bsize,
                                                     is_v5, has_ftype,
                                                     /*accept_block=*/true,
                                                     /*accept_data=*/true,
                                                     entries);
            if (!parsed) {
                // Some implementations have other auxiliary blocks (free
                // space tracker XD2F/XDF3) inside the data range; skip them.
                continue;
            }
            const uint32_t magic = xfs::be32(blk.data());
            if (magic == xfs::XFS_DIR2_BLOCK_MAGIC ||
                magic == xfs::XFS_DIR3_BLOCK_MAGIC) any_block_magic_seen = true;
            if (magic == xfs::XFS_DIR2_DATA_MAGIC ||
                magic == xfs::XFS_DIR3_DATA_MAGIC) any_data_magic_seen = true;
            for (auto& e : entries) out.push_back(std::move(e));
        }
    }
 
    if (!any_block_magic_seen && !any_data_magic_seen) {
        logs.push_back("XFS dir: no recognised data block magic in extent list");
        return false;
    }
    return true;
}

References xfs::be32(), xfs::Superblock::blocksize, collect_dir_entries_block_or_leaf(), xfs::fsb_to_disk_offset(), xfs::Superblock::is_v5(), xfs::parse_dir_data_block(), DiskReader::read_at(), xfs::VolumeContext::sb, xfs::XFS_DIR2_BLOCK_MAGIC, xfs::XFS_DIR2_DATA_MAGIC, xfs::XFS_DIR3_BLOCK_MAGIC, and xfs::XFS_DIR3_DATA_MAGIC.

Referenced by collect_dir_entries_block_or_leaf().

collect_extents()

bool anonymous_namespace{xfs_recovery.cpp}::collect_extents	(	DiskReader &	reader,
		const xfs::VolumeContext &	vol,
		const xfs::DinodeCore &	core,
		const unsigned char *	fork_data,
		uint32_t	fork_len,
		uint32_t	max_extents,
		std::vector< xfs::Extent > &	out,
		std::vector< std::string > &	logs,
		std::string &	err )

Definition at line 260 of file xfs_recovery.cpp.

                                     {
    out.clear();
    if (core.format == xfs::XFS_DINODE_FMT_EXTENTS) {
        if (!xfs::decode_extents_inline(fork_data, core.nextents, fork_len, out)) {
            err = "Corrupted inline extent list (count exceeds fork size)";
            return false;
        }
        return true;
    }
    if (core.format == xfs::XFS_DINODE_FMT_BTREE) {
        // BMBT root sits in the data fork.
        return xfs::walk_extent_btree_root(reader, vol,
                                            fork_data, fork_len,
                                            vol.sb.is_v5(),
                                            max_extents,
                                            out, logs, err);
    }
    err = "Unsupported di_format=" + std::to_string(core.format);
    return false;
}

References collect_extents(), xfs::decode_extents_inline(), xfs::DinodeCore::format, xfs::Superblock::is_v5(), xfs::DinodeCore::nextents, xfs::VolumeContext::sb, xfs::walk_extent_btree_root(), xfs::XFS_DINODE_FMT_BTREE, and xfs::XFS_DINODE_FMT_EXTENTS.

Referenced by collect_extents().

load_ag_headers()

void anonymous_namespace{xfs_recovery.cpp}::load_ag_headers	(	DiskReader &	reader,
		uint64_t	volume_offset,
		const xfs::Superblock &	sb,
		uint32_t	agno,
		xfs::AGContext &	ag,
		std::vector< std::string > &	logs )

Definition at line 82 of file xfs_recovery.cpp.

                                                                   {
    const uint64_t ag_byte_offset =
        volume_offset +
        static_cast<uint64_t>(agno) * sb.agblocks * sb.blocksize;
 
    // AGF lives at sector 1 of the AG (i.e. offset = sectsize)
    const uint64_t agf_off = ag_byte_offset + sb.sectsize;
    // AGI lives at sector 2 of the AG (offset = 2*sectsize)
    const uint64_t agi_off = ag_byte_offset + 2u * sb.sectsize;
 
    // AGF: read one sector (V5 header is 92 bytes plus padding to a sector)
    {
        std::vector<unsigned char> buf(sb.sectsize, 0);
        if (read_exact(reader, agf_off, buf.data(), buf.size())) {
            xfs::AGF agf;
            if (xfs::parse_agf(buf.data(), agf)) {
                ag.agf = agf;
                ag.agf_loaded = true;
            } else {
                std::ostringstream m;
                m << "AGF magic/version invalid in AG " << agno;
                logs.push_back(m.str());
            }
        } else {
            std::ostringstream m;
            m << "Failed to read AGF for AG " << agno
              << " at offset " << agf_off;
            logs.push_back(m.str());
        }
    }
 
    // AGI: same idea, one sector. We need is_v5 to read the FINOBT
    // root/level fields, which live past the V4 AGI footprint.
    {
        std::vector<unsigned char> buf(sb.sectsize, 0);
        if (read_exact(reader, agi_off, buf.data(), buf.size())) {
            xfs::AGI agi;
            if (xfs::parse_agi(buf.data(), sb.is_v5(), agi)) {
                ag.agi = agi;
                ag.agi_loaded = true;
            } else {
                std::ostringstream m;
                m << "AGI magic/version invalid in AG " << agno;
                logs.push_back(m.str());
            }
        } else {
            std::ostringstream m;
            m << "Failed to read AGI for AG " << agno
              << " at offset " << agi_off;
            logs.push_back(m.str());
        }
    }
}

References xfs::Superblock::agblocks, xfs::AGContext::agf, xfs::AGContext::agf_loaded, xfs::AGContext::agi, xfs::AGContext::agi_loaded, xfs::Superblock::blocksize, xfs::Superblock::is_v5(), load_ag_headers(), xfs::parse_agf(), xfs::parse_agi(), read_exact(), xfs::Superblock::sectsize, and DiskReader::size().

Referenced by load_ag_headers().

read_dinode()

bool anonymous_namespace{xfs_recovery.cpp}::read_dinode	(	DiskReader &	reader,
		const xfs::VolumeContext &	vol,
		uint64_t	ino,
		std::vector< unsigned char > &	buf )

Definition at line 146 of file xfs_recovery.cpp.

                                                              {
    const xfs::InodeAddress addr = xfs::crack_inode(ino, vol.sb);
    if (addr.agno >= vol.sb.agcount) return false;
    const uint64_t disk_off =
          vol.volume_offset
        + static_cast<uint64_t>(addr.agno) * vol.sb.agblocks * vol.sb.blocksize
        + static_cast<uint64_t>(addr.agbno) * vol.sb.blocksize
        + static_cast<uint64_t>(addr.offset) * vol.sb.inodesize;
    buf.assign(vol.sb.inodesize, 0);
    return reader.read_at(disk_off, buf.data(), buf.size());
}

References xfs::Superblock::agblocks, xfs::InodeAddress::agbno, xfs::Superblock::agcount, xfs::InodeAddress::agno, xfs::Superblock::blocksize, xfs::crack_inode(), xfs::Superblock::inodesize, xfs::InodeAddress::offset, DiskReader::read_at(), read_dinode(), xfs::VolumeContext::sb, and xfs::VolumeContext::volume_offset.

Referenced by read_dinode().

read_exact()

bool anonymous_namespace{xfs_recovery.cpp}::read_exact	(	DiskReader &	reader,
		uint64_t	off,
		void *	dst,
		size_t	n )

Definition at line 55 of file xfs_recovery.cpp.

                                                                       {
    return reader.read_at(off, dst, n);
}

References DiskReader::read_at(), and read_exact().

Referenced by load_ag_headers(), and read_exact().

read_extents_data()

bool anonymous_namespace{xfs_recovery.cpp}::read_extents_data	(	DiskReader &	reader,
		const xfs::VolumeContext &	vol,
		const std::vector< xfs::Extent > &	extents,
		uint64_t	file_size,
		std::vector< unsigned char > &	out,
		std::string &	err )

Definition at line 290 of file xfs_recovery.cpp.

                                       {
    out.assign(static_cast<size_t>(file_size), 0);
    const uint64_t bsize = vol.sb.blocksize;
 
    auto sorted = extents;
    std::sort(sorted.begin(), sorted.end(),
              [](const xfs::Extent& a, const xfs::Extent& b) {
                  return a.logical_off_blocks < b.logical_off_blocks;
              });
 
    for (const auto& ext : sorted) {
        const uint64_t lo_byte = ext.logical_off_blocks * bsize;
        if (lo_byte >= file_size) break;
        const uint64_t span = std::min<uint64_t>(
            static_cast<uint64_t>(ext.length_blocks) * bsize,
            file_size - lo_byte);
        if (ext.unwritten) continue; // already zero-filled
        const uint64_t phys_off = xfs::fsb_to_disk_offset(ext.physical_block, vol);
        // Read in block-sized chunks so we don't allocate huge buffers.
        std::vector<unsigned char> chunk(bsize, 0);
        uint64_t left = span;
        uint64_t cur_phys = phys_off;
        size_t out_pos = static_cast<size_t>(lo_byte);
        while (left > 0) {
            if (!reader.read_at(cur_phys, chunk.data(), bsize)) {
                err = "Read error at physical offset " + std::to_string(cur_phys);
                return false;
            }
            const size_t step = static_cast<size_t>(std::min<uint64_t>(bsize, left));
            std::memcpy(out.data() + out_pos, chunk.data(), step);
            out_pos += step;
            left -= step;
            cur_phys += bsize;
        }
    }
    return true;
}

References xfs::Superblock::blocksize, xfs::fsb_to_disk_offset(), DiskReader::read_at(), read_extents_data(), and xfs::VolumeContext::sb.

Referenced by read_extents_data().

validate_geometry()

bool anonymous_namespace{xfs_recovery.cpp}::validate_geometry	(	DiskReader &	reader,
		uint64_t	volume_offset,
		const xfs::Superblock &	sb,
		std::string &	err )

Definition at line 62 of file xfs_recovery.cpp.

                                                                {
    const uint64_t disk_size = reader.size();
    if (volume_offset >= disk_size) {
        err = "Volume offset beyond disk end";
        return false;
    }
    const uint64_t fs_size = sb.volume_size_bytes();
    if (volume_offset + fs_size > disk_size + 64u * 1024) {
        // A small slack (64 KiB) accounts for some images that report a
        // FS slightly larger than the partition (rare but seen).
        err = "Filesystem extends past end of disk";
        return false;
    }
    return true;
}

References DiskReader::size(), validate_geometry(), and xfs::Superblock::volume_size_bytes().

Referenced by validate_geometry().

write_extents_to_path()

bool anonymous_namespace{xfs_recovery.cpp}::write_extents_to_path	(	DiskReader &	reader,
		const xfs::VolumeContext &	vol,
		std::vector< xfs::Extent >	extents,
		uint64_t	file_size,
		const fs::path &	out_path,
		std::string &	err )

Definition at line 163 of file xfs_recovery.cpp.

                                            {
    std::ofstream out(out_path, std::ios::binary | std::ios::trunc);
    if (!out) {
        err = "Cannot create output file: " + out_path.string();
        return false;
    }
 
    const uint64_t bsize = vol.sb.blocksize;
    uint64_t bytes_written = 0;
 
    // Sort by logical offset to handle out-of-order extent lists
    std::sort(extents.begin(), extents.end(),
              [](const xfs::Extent& a, const xfs::Extent& b) {
                  return a.logical_off_blocks < b.logical_off_blocks;
              });
 
    for (const auto& ext : extents) {
        const uint64_t logical_byte = ext.logical_off_blocks * bsize;
        const uint64_t ext_bytes    = static_cast<uint64_t>(ext.length_blocks) * bsize;
 
        // Stop once we've reached file_size (the last extent may overlap past EOF).
        if (logical_byte >= file_size) break;
 
        // Pad zeros for any hole between bytes_written and logical_byte
        if (logical_byte > bytes_written) {
            const uint64_t pad = std::min(logical_byte, file_size) - bytes_written;
            std::vector<char> zeros(static_cast<size_t>(std::min<uint64_t>(pad, 64u * 1024)), 0);
            uint64_t left = pad;
            while (left > 0) {
                const size_t step = static_cast<size_t>(std::min<uint64_t>(zeros.size(), left));
                out.write(zeros.data(), static_cast<std::streamsize>(step));
                left -= step;
            }
            bytes_written = std::min(logical_byte, file_size);
        }
 
        // For unwritten extents, write zeros for their length (within file_size).
        const uint64_t copy_bytes = std::min<uint64_t>(ext_bytes,
                                                       file_size - bytes_written);
        if (ext.unwritten) {
            std::vector<char> zeros(64 * 1024, 0);
            uint64_t left = copy_bytes;
            while (left > 0) {
                const size_t step = static_cast<size_t>(std::min<uint64_t>(zeros.size(), left));
                out.write(zeros.data(), static_cast<std::streamsize>(step));
                left -= step;
            }
            bytes_written += copy_bytes;
            continue;
        }
 
        // Real extent: read each block and write to output
        const uint64_t phys_off = xfs::fsb_to_disk_offset(ext.physical_block, vol);
        std::vector<unsigned char> chunk(bsize, 0);
        uint64_t left = copy_bytes;
        uint64_t cur_phys = phys_off;
        while (left > 0) {
            if (!reader.read_at(cur_phys, chunk.data(), bsize)) {
                err = "Read error at physical offset " + std::to_string(cur_phys);
                return false;
            }
            const size_t step = static_cast<size_t>(std::min<uint64_t>(bsize, left));
            out.write(reinterpret_cast<const char*>(chunk.data()),
                      static_cast<std::streamsize>(step));
            left -= step;
            cur_phys += bsize;
        }
        bytes_written += copy_bytes;
 
        if (bytes_written >= file_size) break;
    }
 
    // Final tail: pad zeros if file ends in a hole
    if (bytes_written < file_size) {
        const uint64_t tail = file_size - bytes_written;
        std::vector<char> zeros(64 * 1024, 0);
        uint64_t left = tail;
        while (left > 0) {
            const size_t step = static_cast<size_t>(std::min<uint64_t>(zeros.size(), left));
            out.write(zeros.data(), static_cast<std::streamsize>(step));
            left -= step;
        }
    }
    return true;
}

References xfs::Superblock::blocksize, xfs::fsb_to_disk_offset(), DiskReader::read_at(), xfs::VolumeContext::sb, and write_extents_to_path().

Referenced by write_extents_to_path().

Variable Documentation

XFS_DIR2_LEAF_OFFSET_BLOCKS

uint64_t anonymous_namespace{xfs_recovery.cpp}::XFS_DIR2_LEAF_OFFSET_BLOCKS = 32ull * 1024ull * 1024ull * 1024ull / 4096ull

constexpr

Definition at line 346 of file xfs_recovery.cpp.