Function walk_inode_hashtable

src/os/linux/pagecache.cpp:460–527

Walk the GLOBAL inode hashtable. This is the only reliable way to find every cached inode on modern (≥ ~5.x) kernels — `super_block.s_inodes` is frequently sparse because most inodes spend their cached life on the per-sb LRU and aren't kept on s_inodes. inode_hashtable is a `struct hlist_head *` array of `1 << i_hash_shift` entries (8 bytes each — single `first` pointer per bucket). Each cached i

// entries (8 bytes each — single `first` pointer per bucket). Each cached
// inode is linked into one bucket via `inode.i_hash` (hlist_node @ 0xd0).
std::vector<VAddr> walk_inode_hashtable(const Engine& eng, const Offsets& o)
{
    std::vector<VAddr> inodes;
    const auto& isf = eng.isf();
    if (o.in_i_hash == 0) {
        log::warn("inode_hashtable: ISF has no inode.i_hash field");
        return inodes;
    }

    auto* tbl_sym   = isf.find_symbol("inode_hashtable");
    auto* shift_sym = isf.find_symbol("i_hash_shift");
    if (!tbl_sym || !shift_sym) {
        log::warn("inode_hashtable: missing inode_hashtable / i_hash_shift "
                  "symbols");
        return inodes;
    }

    VAddr table_va = 0;
    if (!kva_read_pod(eng, tbl_sym->address, table_va) || table_va == 0) {
        log::warn("inode_hashtable: cannot read table pointer");
        return inodes;
    }
    u32 hash_shift = 0;
    if (!kva_read_pod(eng, shift_sym->address, hash_shift) ||
        hash_shift == 0 || hash_shift > 30)
    {
        log::warn("inode_hashtable: bad hash_shift = {}", hash_shift);
        return inodes;
    }
    const u64 buckets = 1ULL << hash_shift;
    log::debug("inode_hashtable @ {:#x} ({} buckets)", table_va, buckets);

    // Read the array in big chunks to amortise PGD walks.
    constexpr u64 kChunk = 0x10000;       // 64 KiB at a time (8192 ptrs)
    std::vector<VAddr> chunk(kChunk / sizeof(VAddr), 0);
    constexpr std::size_t kInodeCap = 500'000;
    std::size_t empty_buckets = 0;

    for (u64 start = 0; start < buckets; start += chunk.size()) {
        u64 want = std::min<u64>(chunk.size(), buckets - start);
        std::size_t bytes = want * sizeof(VAddr);
        std::memset(chunk.data(), 0, bytes);
        kva_read(eng, table_va + start * sizeof(VAddr), chunk.data(), bytes);

        for (u64 i = 0; i < want; ++i) {
            VAddr node = chunk[i];
            if (node == 0) { ++empty_buckets; continue; }
            // Walk the hlist chain in this bucket.
            int chain_guard = 0;
            while (node != 0 && chain_guard++ < 1'000'000 &&
                   inodes.size() < kInodeCap)
            {
                VAddr inode_va = node - o.in_i_hash;
                inodes.push_back(inode_va);

                // Next link is at hlist_node offset 0.
                VAddr next = 0;
                if (!kva_read_pod(eng, node, next) || next == node) break;