XfsRecovery Class Reference

#include <xfs_recovery.hpp>

Public Member Functions
	XfsRecovery (DiskReader &reader)
bool	recover (uint64_t volume_offset, const std::string &output_dir, std::vector< RecoveredFileRecord > &recovered, std::vector< std::string > &logs, std::string &error)

Private Attributes
DiskReader &	reader_

Detailed Description

Definition at line 29 of file xfs_recovery.hpp.

Constructor & Destructor Documentation

XfsRecovery()

XfsRecovery::XfsRecovery ( DiskReader & reader )

explicit

Definition at line 415 of file xfs_recovery.cpp.

: reader_(reader) {}

References reader_.

Member Function Documentation

recover()

bool XfsRecovery::recover	(	uint64_t	volume_offset,
		const std::string &	output_dir,
		std::vector< RecoveredFileRecord > &	recovered,
		std::vector< std::string > &	logs,
		std::string &	error )

Definition at line 417 of file xfs_recovery.cpp.

                                            {
    logs.push_back(trs("XFS recovery (session 4: full dir/file extraction) starting at offset") +
                   std::string(" ") + std::to_string(volume_offset));
 
    // ---- Step 1: read and parse the volume superblock ----
    std::array<unsigned char, 512> sb_sector{};
    if (!read_exact(reader_, volume_offset, sb_sector.data(), sb_sector.size())) {
        error = trs("XFS: cannot read superblock");
        return false;
    }
 
    xfs::Superblock sb;
    if (!xfs::parse_superblock(sb_sector.data(), sb)) {
        error = trs("XFS: not a valid superblock at this offset");
        return false;
    }
 
    // Geometry sanity vs disk
    {
        std::string ge;
        if (!validate_geometry(reader_, volume_offset, sb, ge)) {
            error = trs("XFS: geometry inconsistent:") + std::string(" ") + ge;
            return false;
        }
    }
 
    // ---- Step 2: log the volume layout (helps the user / debugging) ----
    {
        std::ostringstream m;
        m << "XFS volume identified: V" << sb.format_version()
          << " blocksize=" << sb.blocksize
          << " sectsize=" << sb.sectsize
          << " inodesize=" << sb.inodesize
          << " agcount=" << sb.agcount
          << " agblocks=" << sb.agblocks
          << " dblocks=" << sb.dblocks
          << " size=" << (sb.volume_size_bytes() / (1024 * 1024)) << " MiB";
        const std::string lbl = sb.label();
        if (!lbl.empty()) m << " label=\"" << lbl << "\"";
        logs.push_back(m.str());
    }
 
    if (sb.is_v5()) {
        std::ostringstream m;
        m << "XFS V5 features: ";
        bool any = false;
        if (sb.features_incompat & xfs::XFS_SB_FEAT_INCOMPAT_FTYPE)   { m << "FTYPE ";   any = true; }
        if (sb.features_incompat & xfs::XFS_SB_FEAT_INCOMPAT_SPINODES){ m << "SPARSE ";  any = true; }
        if (sb.features_incompat & xfs::XFS_SB_FEAT_INCOMPAT_BIGTIME) { m << "BIGTIME "; any = true; }
        if (sb.features_incompat & xfs::XFS_SB_FEAT_INCOMPAT_NREXT64) { m << "NREXT64 "; any = true; }
        if (sb.features_ro_compat & xfs::XFS_SB_FEAT_RO_COMPAT_FINOBT){ m << "FINOBT ";  any = true; }
        if (sb.features_ro_compat & xfs::XFS_SB_FEAT_RO_COMPAT_REFLINK){m << "REFLINK "; any = true; }
        if (!any) m << "(none)";
        logs.push_back(m.str());
    }
 
    // ---- Step 3: build the volume context, load AG headers ----
    xfs::VolumeContext vol;
    vol.sb = sb;
    vol.volume_offset = volume_offset;
    vol.ag.assign(sb.agcount, xfs::AGContext{});
 
    // Cap iteration to a reasonable maximum to defend against pathological
    // SB values (we already validated agcount above, this is belt-and-braces).
    constexpr uint32_t MAX_AG_TO_PROBE = 4096;
    const uint32_t agcount = std::min<uint32_t>(sb.agcount, MAX_AG_TO_PROBE);
 
    uint32_t agf_ok = 0, agi_ok = 0;
    for (uint32_t i = 0; i < agcount; ++i) {
        load_ag_headers(reader_, volume_offset, sb, i, vol.ag[i], logs);
        if (vol.ag[i].agf_loaded) ++agf_ok;
        if (vol.ag[i].agi_loaded) ++agi_ok;
    }
 
    {
        std::ostringstream m;
        m << "XFS AG headers loaded: AGF " << agf_ok << "/" << agcount
          << ", AGI " << agi_ok << "/" << agcount;
        logs.push_back(m.str());
    }
 
    if (agf_ok == 0 && agi_ok == 0) {
        error = trs("XFS: no AG headers could be parsed; volume looks corrupt or "
                    "this is a partition without an XFS volume at offset 0");
        return false;
    }
 
    // Per AG with a loaded AGI, emit one line of diagnostics that will be
    // useful when we add inode iteration in session 2.
    for (uint32_t i = 0; i < agcount; ++i) {
        if (!vol.ag[i].agi_loaded) continue;
        std::ostringstream m;
        m << "  AG " << i
          << ": ialloc=" << vol.ag[i].agi.count
          << " ifree="   << vol.ag[i].agi.freecount
          << " ibtree_root=blk" << vol.ag[i].agi.root
          << " ibtree_depth=" << vol.ag[i].agi.level;
        logs.push_back(m.str());
    }
 
    // ---- Step 4: tree-walk from the root inode and export files ----
    //
    // We start at sb.rootino and recursively descend through shortform
    // directories. For every regular file in extents format we read the
    // file content via the extent list and write it to the output dir.
    // For symlinks (shortform) we write the link target as a small file.
    // For shortform regular files (di_format=1, rare) we dump the inline
    // bytes.
    //
    // We do NOT yet handle directory block/leaf/node formats or extent
    // B+tree (di_format=3). Those land in session 4.
 
    constexpr int MAX_DEPTH = 64;        // defensive against pathological dirs
    constexpr size_t MAX_FILES = 200'000; // safety cap on exported files
 
    // Output root: <output_dir>/filesystem_recovered/xfs/offset_<N>/
    fs::path xfs_out_root =
        fs::path(output_dir) / "filesystem_recovered" / "xfs" /
        ("offset_" + std::to_string(volume_offset));
    {
        std::error_code ec;
        fs::create_directories(xfs_out_root, ec);
        if (ec) {
            error = "Cannot create output directory: " + xfs_out_root.string();
            return false;
        }
    }
 
    std::set<uint64_t> visited_inodes;
    size_t files_exported = 0;
    size_t dirs_walked = 0;
    size_t skipped_unsupported = 0;
    size_t errors_logged = 0;
 
    // Recursive walker. Returns false ONLY on fatal user-level cap.
    // For per-inode errors we just log and continue.
    std::function<bool(uint64_t, const fs::path&, int)> walk_dir =
        [&](uint64_t ino, const fs::path& out_dir, int depth) -> bool
    {
        if (depth >= MAX_DEPTH) {
            logs.push_back("XFS: max recursion depth reached, stopping branch.");
            return true;
        }
        if (!visited_inodes.insert(ino).second) {
            return true; // cycle, skip
        }
        if (files_exported >= MAX_FILES) {
            logs.push_back("XFS: file export safety cap reached ("
                           + std::to_string(MAX_FILES) + ").");
            return false;
        }
 
        std::vector<unsigned char> ibuf;
        if (!read_dinode(reader_, vol, ino, ibuf)) {
            ++errors_logged;
            logs.push_back("XFS: failed to read dinode for ino "
                           + std::to_string(ino));
            return true;
        }
        xfs::DinodeCore core;
        if (!xfs::parse_dinode_core(ibuf.data(), core)) {
            ++errors_logged;
            logs.push_back("XFS: bad dinode magic at ino "
                           + std::to_string(ino));
            return true;
        }
        if (!core.is_dir()) {
            // Not a directory -- this should only happen on the very
            // first call if rootino isn't actually a dir (corrupt SB).
            return true;
        }
        ++dirs_walked;
 
        const uint32_t fork_off = xfs::dinode_data_fork_offset(core);
        const uint32_t fork_len = xfs::dinode_data_fork_length(core, vol.sb.inodesize);
        const unsigned char* fork = ibuf.data() + fork_off;
 
        // Build a uniform "list of entries" regardless of which directory
        // format the dinode uses (shortform / block / leaf / node / btree).
        // Each branch fills `dir_entries`.
        std::vector<xfs::DirEntry> dir_entries;
 
        if (core.format == xfs::XFS_DINODE_FMT_LOCAL) {
            xfs::ShortformDir sf;
            if (!xfs::parse_shortform_dir(fork, fork_len,
                                           vol.sb.has_ftype(), sf)) {
                ++errors_logged;
                logs.push_back("XFS: cannot parse shortform dir at ino "
                               + std::to_string(ino));
                return true;
            }
            dir_entries = std::move(sf.entries);
        }
        else if (core.format == xfs::XFS_DINODE_FMT_EXTENTS ||
                 core.format == xfs::XFS_DINODE_FMT_BTREE) {
            // Block-format (single data block) and leaf/node-format
            // (multiple data blocks) directories are both ultimately a
            // sequence of "data blocks" inside the directory's logical
            // address space below 32 GiB. We collect every extent and
            // parse each block uniformly.
            std::vector<xfs::Extent> extents;
            std::string cerr;
            if (!collect_extents(reader_, vol, core, fork, fork_len,
                                  /*max_extents=*/100'000,
                                  extents, logs, cerr)) {
                ++errors_logged;
                logs.push_back("XFS: dir ino " + std::to_string(ino) +
                               " extent list error: " + cerr);
                return true;
            }
            if (!collect_dir_entries_block_or_leaf(reader_, vol, extents,
                                                    vol.sb.has_ftype(),
                                                    dir_entries, logs)) {
                ++errors_logged;
                logs.push_back("XFS: dir ino " + std::to_string(ino) +
                               " could not be parsed (block/leaf format)");
                return true;
            }
        }
        else {
            ++skipped_unsupported;
            std::ostringstream m;
            m << "XFS: directory ino " << ino
              << " uses unsupported di_format="
              << static_cast<int>(core.format);
            logs.push_back(m.str());
            return true;
        }
 
        // For each entry, dispatch on type
        for (const auto& e : dir_entries) {
            const std::string safe_name = text_utils::sanitize_component(e.name);
            const fs::path child_path = out_dir / safe_name;
 
            std::vector<unsigned char> child_buf;
            if (!read_dinode(reader_, vol, e.ino, child_buf)) {
                ++errors_logged;
                logs.push_back("XFS: cannot read child dinode for '"
                               + e.name + "' (ino " + std::to_string(e.ino) + ")");
                continue;
            }
            xfs::DinodeCore child_core;
            if (!xfs::parse_dinode_core(child_buf.data(), child_core)) {
                ++errors_logged;
                logs.push_back("XFS: bad child dinode magic for '"
                               + e.name + "'");
                continue;
            }
 
            const uint32_t cfork_off = xfs::dinode_data_fork_offset(child_core);
            const uint32_t cfork_len = xfs::dinode_data_fork_length(child_core, vol.sb.inodesize);
            const unsigned char* cfork = child_buf.data() + cfork_off;
 
            if (child_core.is_dir()) {
                std::error_code ec;
                fs::create_directories(child_path, ec);
                if (ec) {
                    ++errors_logged;
                    logs.push_back("XFS: cannot mkdir " + child_path.string());
                    continue;
                }
                if (!walk_dir(e.ino, child_path, depth + 1)) return false;
            }
            else if (child_core.is_reg()) {
                // Two cases: file in extents/btree format, or rare inline.
                if (child_core.format == xfs::XFS_DINODE_FMT_EXTENTS ||
                    child_core.format == xfs::XFS_DINODE_FMT_BTREE) {
                    std::vector<xfs::Extent> extents;
                    std::string cerr;
                    if (!collect_extents(reader_, vol, child_core,
                                         cfork, cfork_len, /*max_extents=*/1'000'000,
                                         extents, logs, cerr)) {
                        ++errors_logged;
                        logs.push_back("XFS: cannot read extents for '" + e.name +
                                       "': " + cerr);
                        continue;
                    }
                    std::string ferr;
                    if (write_extents_to_path(reader_, vol, std::move(extents),
                                              static_cast<uint64_t>(child_core.size),
                                              child_path, ferr)) {
                        const char* note = (child_core.format == xfs::XFS_DINODE_FMT_BTREE)
                                            ? "btree-extents" : "extents";
                        recovered.push_back({
                            child_path.string(), "XFS",
                            (out_dir / safe_name).lexically_relative(xfs_out_root).string(),
                            static_cast<uint64_t>(child_core.size),
                            "full", note});
                        ++files_exported;
                    } else {
                        ++errors_logged;
                        logs.push_back("XFS: failed to export '" + e.name +
                                       "': " + ferr);
                    }
                }
                else if (child_core.format == xfs::XFS_DINODE_FMT_LOCAL) {
                    // Inline file (rare on XFS but exists for tiny files
                    // when forkoff allows it).
                    std::ofstream out(child_path, std::ios::binary | std::ios::trunc);
                    if (out) {
                        const uint64_t bytes = std::min<uint64_t>(
                            static_cast<uint64_t>(child_core.size), cfork_len);
                        out.write(reinterpret_cast<const char*>(cfork),
                                  static_cast<std::streamsize>(bytes));
                        recovered.push_back({
                            child_path.string(), "XFS",
                            (out_dir / safe_name).lexically_relative(xfs_out_root).string(),
                            bytes, "full", "shortform-inline"});
                        ++files_exported;
                    } else {
                        ++errors_logged;
                        logs.push_back("XFS: cannot create file " + child_path.string());
                    }
                }
                else {
                    // dev / uuid / ... -- not file content
                    ++skipped_unsupported;
                }
            }
            else if (child_core.is_symlink()) {
                std::string target;
                if (child_core.format == xfs::XFS_DINODE_FMT_LOCAL) {
                    // Inline symlink target.
                    const uint64_t link_bytes = std::min<uint64_t>(
                        static_cast<uint64_t>(child_core.size), cfork_len);
                    target.assign(reinterpret_cast<const char*>(cfork),
                                   static_cast<size_t>(link_bytes));
                }
                else if (child_core.format == xfs::XFS_DINODE_FMT_EXTENTS ||
                         child_core.format == xfs::XFS_DINODE_FMT_BTREE) {
                    // Long symlink: target stored as file data in extents
                    // or BMBT. Read it the same way as a regular file body.
                    std::vector<xfs::Extent> extents;
                    std::string cerr;
                    if (!collect_extents(reader_, vol, child_core,
                                         cfork, cfork_len, /*max_extents=*/256,
                                         extents, logs, cerr)) {
                        ++errors_logged;
                        logs.push_back("XFS: cannot read symlink extents for '"
                                       + e.name + "': " + cerr);
                        continue;
                    }
                    std::vector<unsigned char> body;
                    std::string rerr;
                    if (!read_extents_data(reader_, vol, extents,
                                            static_cast<uint64_t>(child_core.size),
                                            body, rerr)) {
                        ++errors_logged;
                        logs.push_back("XFS: cannot read symlink body for '"
                                       + e.name + "': " + rerr);
                        continue;
                    }
                    target.assign(reinterpret_cast<const char*>(body.data()),
                                   body.size());
                }
                else {
                    ++skipped_unsupported;
                    continue;
                }
 
                // Try to make a real symlink first; if that fails (e.g.
                // target outside the export dir, perms), write a sidecar.
                std::error_code ec;
                fs::create_symlink(target, child_path, ec);
                if (ec) {
                    std::ofstream out(child_path.string() + ".symlink",
                                      std::ios::binary | std::ios::trunc);
                    if (out) out << target;
                }
                recovered.push_back({
                    child_path.string(), "XFS",
                    (out_dir / safe_name).lexically_relative(xfs_out_root).string(),
                    target.size(), "full",
                    (child_core.format == xfs::XFS_DINODE_FMT_LOCAL)
                        ? "symlink-shortform" : "symlink-extents"});
                ++files_exported;
            }
            else if (child_core.is_special()) {
                // Char/block/fifo/socket -- nothing meaningful to export.
                ++skipped_unsupported;
            }
            else {
                ++skipped_unsupported;
            }
        }
        return true;
    };
 
    // Kick off the walk from the root inode.
    if (sb.rootino == 0) {
        error = "XFS: superblock has no root inode (rootino=0).";
        return false;
    }
    walk_dir(sb.rootino, xfs_out_root, 0);
 
    // ---- Step 5 (session 5): FINOBT pass for recently-deleted file recovery
    //
    // Only on V5 volumes with FINOBT feature. For each free inode slot,
    // try to read the dinode -- if the inode wasn't yet reused by XFS,
    // it still holds the deleted file's data. We export to a flat
    // "deleted/" subdirectory because we have no way to reconstruct the
    // original directory path or filename: the dirent that named it has
    // already been removed from the parent.
 
    size_t deleted_recovered = 0;
    size_t deleted_attempted = 0;
    size_t deleted_stale = 0;     // valid magic but format/mode implausible
 
    if (sb.is_v5() &&
        (sb.features_ro_compat & xfs::XFS_SB_FEAT_RO_COMPAT_FINOBT)) {
 
        fs::path deleted_dir = xfs_out_root / "deleted";
        std::error_code dec;
        fs::create_directories(deleted_dir, dec);
 
        // Collect candidates from FINOBT
        std::vector<xfs::AllocatedInode> free_slots;
        auto fcb = [&](const xfs::InobtRec& rec, uint32_t agno) -> bool {
            xfs::expand_chunk_free(rec, agno, vol, free_slots);
            // Safety cap: don't enumerate more than 200k stale slots
            if (free_slots.size() >= 200'000) {
                logs.push_back("XFS FINOBT: candidate cap reached (200k slots)");
                return false;
            }
            return true;
        };
        std::vector<std::string> finobt_logs;
        xfs::walk_all_free_inode_records(reader_, vol, fcb, finobt_logs);
        for (auto& l : finobt_logs) logs.push_back(std::move(l));
 
        logs.push_back("XFS FINOBT: " + std::to_string(free_slots.size())
                       + " free-inode candidates collected.");
 
        // For each free slot, try to read the stale dinode
        for (const auto& fi : free_slots) {
            // Skip slots we already saw as live inodes (defensive --
            // shouldn't happen in a healthy FS, but FINOBT and IBT can
            // disagree on damaged volumes).
            if (visited_inodes.count(fi.ino) != 0) continue;
            ++deleted_attempted;
 
            std::vector<unsigned char> ibuf(vol.sb.inodesize, 0);
            if (!reader_.read_at(fi.disk_offset, ibuf.data(), ibuf.size())) {
                continue;
            }
            xfs::DinodeCore core;
            if (!xfs::parse_dinode_core(ibuf.data(), core)) {
                continue;  // dinode already overwritten or never written
            }
 
            // Heuristic checks: a "still recoverable" stale dinode
            // typically still has its original mode/format/size. If
            // mode == 0 or size == 0 or format is exotic, skip.
            if (core.mode == 0) { ++deleted_stale; continue; }
            if (core.size <= 0) { ++deleted_stale; continue; }
 
            // We only recover regular files here. Recovering a deleted
            // directory's content is complicated (the data blocks may
            // be partially overwritten, the dirent records would need
            // to be cross-referenced) and out of scope for this session.
            if (!core.is_reg()) { ++deleted_stale; continue; }
 
            const uint32_t cfork_off = xfs::dinode_data_fork_offset(core);
            const uint32_t cfork_len = xfs::dinode_data_fork_length(core,
                                                       vol.sb.inodesize);
            const unsigned char* cfork = ibuf.data() + cfork_off;
 
            // Build a synthetic filename: inode_<NUM>.bin
            std::ostringstream nm;
            nm << "inode_" << fi.ino << ".bin";
            const fs::path out_path = deleted_dir / nm.str();
 
            std::vector<xfs::Extent> extents;
            std::vector<std::string> ex_logs;
            std::string ex_err;
            if (!collect_extents(reader_, vol, core, cfork, cfork_len,
                                 1'000'000, extents, ex_logs, ex_err)) {
                ++deleted_stale;
                continue;
            }
            // Skip files with no extents (typical for never-written or
            // already-overwritten slots)
            if (extents.empty() && core.format != xfs::XFS_DINODE_FMT_LOCAL) {
                ++deleted_stale;
                continue;
            }
 
            std::vector<unsigned char> file_data;
            if (core.format == xfs::XFS_DINODE_FMT_LOCAL) {
                // Inline file: just copy the inline bytes
                const uint64_t bytes = std::min<uint64_t>(
                    static_cast<uint64_t>(core.size), cfork_len);
                file_data.assign(cfork, cfork + bytes);
            } else {
                if (!read_extents_data(reader_, vol, extents,
                                       static_cast<uint64_t>(core.size),
                                       file_data, ex_err)) {
                    ++deleted_stale;
                    continue;
                }
            }
 
            std::ofstream out(out_path, std::ios::binary | std::ios::trunc);
            if (!out) { ++deleted_stale; continue; }
            out.write(reinterpret_cast<const char*>(file_data.data()),
                      static_cast<std::streamsize>(file_data.size()));
            recovered.push_back({
                out_path.string(), "XFS",
                ("deleted/" + nm.str()),
                file_data.size(), "deleted", "finobt"});
            ++deleted_recovered;
        }
 
        std::ostringstream m;
        m << "XFS FINOBT: deleted-file recovery -- attempted "
          << deleted_attempted << " slots, recovered "
          << deleted_recovered << " files, "
          << deleted_stale << " stale/unsupported.";
        logs.push_back(m.str());
 
        if (deleted_recovered == 0 && deleted_attempted > 0) {
            logs.push_back("XFS FINOBT: no deleted files recovered. "
                           "This is normal on a long-running filesystem "
                           "where free inode slots have been overwritten "
                           "by new allocations. Recovery only works on "
                           "deletions that occurred since the last reuse.");
        }
    }
 
    {
        std::ostringstream m;
        m << "XFS recovery completed. "
          << "Files exported: " << files_exported
          << ", directories walked: " << dirs_walked
          << ", deleted files recovered: " << deleted_recovered
          << ", skipped (non-shortform/unsupported): " << skipped_unsupported
          << ", per-inode errors: " << errors_logged << ".";
        logs.push_back(m.str());
    }
 
    // Note for the user: residual unsupported items
    if (skipped_unsupported > 0) {
        logs.push_back("XFS: some entries were skipped (special device files, "
                       "non-standard inode formats, or unrecognised data blocks). "
                       "Regular shortform/block/leaf directories and "
                       "extents/btree files were processed.");
    }
 
    return files_exported > 0 || dirs_walked > 0 || deleted_recovered > 0;
}

References xfs::VolumeContext::ag, xfs::Superblock::agblocks, xfs::Superblock::agcount, xfs::Superblock::blocksize, xfs::Superblock::dblocks, xfs::dinode_data_fork_length(), xfs::dinode_data_fork_offset(), xfs::ShortformDir::entries, xfs::expand_chunk_free(), xfs::Superblock::features_incompat, xfs::Superblock::features_ro_compat, xfs::DinodeCore::format, xfs::Superblock::format_version(), xfs::Superblock::has_ftype(), xfs::Superblock::inodesize, xfs::DinodeCore::is_dir(), xfs::DinodeCore::is_reg(), xfs::DinodeCore::is_special(), xfs::DinodeCore::is_symlink(), xfs::Superblock::is_v5(), xfs::Superblock::label(), xfs::DinodeCore::mode, xfs::parse_dinode_core(), xfs::parse_shortform_dir(), xfs::parse_superblock(), DiskReader::read_at(), reader_, xfs::Superblock::rootino, text_utils::sanitize_component(), xfs::VolumeContext::sb, xfs::Superblock::sectsize, DiskReader::size(), xfs::DinodeCore::size, trs(), xfs::VolumeContext::volume_offset, xfs::Superblock::volume_size_bytes(), xfs::walk_all_free_inode_records(), xfs::XFS_DINODE_FMT_BTREE, xfs::XFS_DINODE_FMT_EXTENTS, xfs::XFS_DINODE_FMT_LOCAL, xfs::XFS_SB_FEAT_INCOMPAT_BIGTIME, xfs::XFS_SB_FEAT_INCOMPAT_FTYPE, xfs::XFS_SB_FEAT_INCOMPAT_NREXT64, xfs::XFS_SB_FEAT_INCOMPAT_SPINODES, xfs::XFS_SB_FEAT_RO_COMPAT_FINOBT, and xfs::XFS_SB_FEAT_RO_COMPAT_REFLINK.

Member Data Documentation

reader_

DiskReader& XfsRecovery::reader_

private

Definition at line 41 of file xfs_recovery.hpp.

Referenced by recover(), and XfsRecovery().

---

The documentation for this class was generated from the following files:

• BastionGuard/thirdparty/bastionguard-recovery-data/src/xfs_recovery.hpp
• BastionGuard/thirdparty/bastionguard-recovery-data/src/xfs_recovery.cpp