Fixed missed merge text (oops)

Changed all *const Decompressor to *Decompressor
Changed all decompressors to only stateless (my queues are borked)

README.md

@@ -10,9 +10,13 @@ Overall works, but currently is missing some features ([see below](#capabilities
 
 ## Build options
 
-> `-Duse_c_libs=true`
+> `-Duse_zig_decomp=true`
 
-Instead of using Zig's standard library for decompression, use the system's C libraries. Has the benefit of being much faster and enabling LZO and LZ4 decompression.
+Instead of using C libraries for decompression, use Zig's standard library for decompression. If using this option LZO and LZ4 decomrpession types are unsupported and decompression times will be significantly longer.
+
+> `-Ddynamic=true`
+
+Dynamicly link C libraries (if they're used) instead of statically linking them.
 
 > `-Dallow_lzo=true`
 
@@ -35,22 +39,22 @@ Most features are present except for the following:
 
 ## Performance
 
-This is some basic observation's I've made about this library's performance when compared to `unsquashfs`. Unless otherwise stated, most observations were made when extracting my test archive (which is fairly small and uses zstd compression) and with `--release=fast`.
+This is some basic observation's I've made about this library's performance when compared to `unsquashfs`. Unless otherwise stated, most observations were made when extracting my test archive which is fairly small and uses zstd compression with `-Doptimize=ReleaseFast`.
 
 Currently, my only performance checks are checking execution time, nothing deeper.
 
-* Under ideal circumstances, my library is ~70% slower (.12s vs .20s).
+* Currently, using my test archive, performance aproximately matches `unsquashfs` when multi-threaded, but significantly slower when single-threaded.
-* Using Zig decompression libraries *significantly* increases decompression time by ~600%. Under ideal circumstances.
+* Using Zig decompression libraries *significantly* increases decompression time.
 * Performance improvements/regressions will be common. I'm still learning Zig.
 
 Example Times:
 
-* *unsquashfs, multi-threaded*: .12s
+* *unsquashfs, multi-threaded*: .11s
 * *unsquashfs, single-threaded*: .13s
-* *C-libs, single-threaded*: .45s
+* *C-libs, multi-threaded*: .10s
-* *C-libs, multi-threaded*: .20s
+* *C-libs, single-threaded*: ..28s
-* *Zig-libs, single-threaded*: 5.78s
+* *Zig-libs, single-threaded*: .74s
-* *Zig-libs, multi-threaded*: 1.08s
+* *Zig-libs, multi-threaded*: 2.70s
 
 ## Build considerations
 

benchmark.sh

@@ -0,0 +1,17 @@
+#! /usr/bin/env bash
+
+ARCHIVE="testing/LinuxPATest.sfs"
+
+REF_EXT_LOC="testing/LinuxPAReference"
+PROG_EXT_LOC="testing/LinuxPABinTest"
+
+echo "Testing Multi-threaded Performance"
+echo ""
+
+hyperfine --warmup 5 --prepare "rm -rf $REF_EXT_LOC && rm -rf $PROG_EXT_LOC" "unsquashfs -d $REF_EXT_LOC $ARCHIVE" "zig-out/bin/unsquashfs -d $PROG_EXT_LOC $ARCHIVE"
+
+echo ""
+echo "Testing Single-threaded Performance"
+echo ""
+
+hyperfine --warmup 5 --prepare "rm -rf $REF_EXT_LOC && rm -rf $PROG_EXT_LOC" "unsquashfs -p 1 -d $REF_EXT_LOC $ARCHIVE" "zig-out/bin/unsquashfs -p 1 -d $PROG_EXT_LOC $ARCHIVE"

build.zig

@@ -1,17 +1,23 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) !void {
-    // const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
+    const use_zig_decomp = b.option(bool, "use_zig_decomp", "Use zig standard library for decompression.") orelse false;
-    // const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
+    const allow_lzo = b.option(bool, "allow_lzo", "Compile with lzo support") orelse false;
-    const debug = b.option(bool, "debug", "Enable options to make debugging easier.");
+    const dynamic = b.option(bool, "dynamic", "Dynamicly link C decompression libraries") orelse false;
+    var debug = b.option(bool, "debug", "Enable options to make debugging easier.");
     const version_string_option = b.option([]const u8, "version", "Version of the library/binary");
 
-    // const zig_squashfs_options = b.addOptions();
+    const zig_squashfs_options = b.addOptions();
-    // zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
+    zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
-    // zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
+    zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
 
     const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
+    var optimize = b.standardOptimizeOption(.{});
+
+    if (debug == true)
+        optimize = .Debug;
+    if (optimize == .Debug)
+        debug = true;
 
     const lib = b.addLibrary(.{
         .name = "squashfs",
@@ -20,10 +26,31 @@ pub fn build(b: *std.Build) !void {
             .target = target,
             .valgrind = debug,
             .root_source_file = b.path("src/root.zig"),
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+            },
         }),
         .use_llvm = debug,
     });
 
+    const deps = try dependencies(b, optimize, target, use_zig_decomp, allow_lzo, dynamic);
+    defer b.allocator.free(deps);
+    for (deps) |d|
+        lib.root_module.linkLibrary(d);
+
+    if (!use_zig_decomp) {
+        const c = b.addTranslateC(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/c.h"),
+        });
+        if (allow_lzo) c.defineCMacro("ALLOW_LZO", null);
+        lib.root_module.addImport("c", c.createModule());
+
+        if (dynamic)
+            dynamicLinkLibraries(c, allow_lzo);
+    }
+
     var version = version_string_option orelse "0.0.0-testing";
     if (version[0] == 'v') version = version[1..];
     const unsquashfs_options = b.addOptions();
@@ -54,9 +81,31 @@ pub fn build(b: *std.Build) !void {
         .root_module = b.createModule(.{
             .optimize = optimize,
             .target = target,
-            .root_source_file = b.path("src/test.zig"),
+            .root_source_file = b.path("src/root.zig"),
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+            },
+            .valgrind = debug,
         }),
+        .use_llvm = debug,
     });
+
+    for (deps) |d|
+        mod_tests.root_module.linkLibrary(d);
+
+    if (!use_zig_decomp) {
+        const c = b.addTranslateC(.{
+            .optimize = optimize,
+            .target = target,
+            .root_source_file = b.path("src/c.h"),
+        });
+        mod_tests.root_module.addImport("c", c.createModule());
+        if (allow_lzo) c.defineCMacro("ALLOW_LZO", null);
+
+        if (dynamic)
+            dynamicLinkLibraries(c, allow_lzo);
+    }
+
     const run_mod_tests = b.addRunArtifact(mod_tests);
     const test_step = b.step("test", "Run tests");
     test_step.dependOn(&run_mod_tests.step);
@@ -74,3 +123,42 @@ pub fn build(b: *std.Build) !void {
     check.dependOn(&lib_check.step);
     check.dependOn(&exe_check.step);
 }
+
+pub fn dynamicLinkLibraries(mod: *std.Build.Step.TranslateC, allow_lzo: bool) void {
+    mod.linkSystemLibrary("zstd", .{});
+    mod.linkSystemLibrary("zlib-ng", .{});
+    mod.linkSystemLibrary("lzma", .{});
+    mod.linkSystemLibrary("lz4", .{});
+    if (allow_lzo)
+        mod.linkSystemLibrary("minilzo", .{});
+}
+fn dependencies(
+    b: *std.Build,
+    optimize: std.builtin.OptimizeMode,
+    target: std.Build.ResolvedTarget,
+    use_zig_decomp: bool,
+    allow_lzo: bool,
+    dynamic: bool,
+) ![]*std.Build.Step.Compile {
+    if (use_zig_decomp or dynamic) return &.{};
+
+    var list: std.ArrayList(*std.Build.Step.Compile) = .empty;
+
+    const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, zstd.artifact("zstd"));
+
+    const zng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, zng.artifact("zng"));
+
+    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, xz.artifact("lzma"));
+
+    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
+    try list.append(b.allocator, lz4.artifact("lz4"));
+
+    if (allow_lzo) {
+        const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
+        try list.append(b.allocator, minilzo.artifact("minilzo"));
+    }
+    return list.toOwnedSlice(b.allocator);
+}

build.zig.zon

@@ -20,6 +20,10 @@
             .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
             .hash = "minilzo-2.10.0-Ij7BO8wLAADeWI4Pe4jp8XTDsDaquZR14oZ7_9yKKDWP",
         },
+        .xz = .{
+            .url = "git+https://github.com/akunaakwei/zig-xz.git#e2d389262c8291907e3e4c6fb119819141c16c0f",
+            .hash = "xz-5.8.2-6v47_JYeAABSL-jonprpL5-E_YaaGc4B5xrbe93WsJ3G",
+        },
     },
     .paths = .{
         "build.zig",

run_tests.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-zig test \
-	-lc \
-	-lz \
-	-llzma \
-	-lminilzo \
-	-llz4 \
-	-lzstd \
-		src/test.zig

src/archive.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const Io = std.Io;
 
+const Decomp = @import("decomp.zig");
 const ExtractionOptions = @import("options.zig");
 const File = @import("file.zig");
 const Inode = @import("inode.zig");
@@ -22,63 +23,44 @@ pub fn init(io: Io, file: std.Io.File, offset: u64) !Archive {
     try rdr.seekTo(offset);
     var super: Superblock = undefined;
     try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
+    try super.validate();
+
     return .{
-        .file = .init(file, offset),
+        .file = try .init(io, file, super.size, offset),
         .super = super,
 
-        .stateless_decomp = switch (super.compression) {
+        .stateless_decomp = try Decomp.StatelessDecomp(super.compression),
-            .gzip => @import("decomp/zlib.zig").stateless_decompressor,
-            .lzma => @import("decomp/lzma.zig").stateless_decompressor,
-            .lzo => return error.LzoUnsupported,
-            .xz => @import("decomp/xz.zig").stateless_decompressor,
-            .lz4 => return error.Lz4Unsupported,
-            .zstd => @import("decomp/zstd.zig").stateless_decompressor,
-        },
     };
 }
+pub fn deinit(self: *Archive, io: Io) void {
+    self.file.deinit(io);
+}
 
 /// The root folder of the Archive. Used to open other Files.
-pub fn root(self: Archive, alloc: std.mem.Allocator, io: Io) !File {
+pub fn root(self: *Archive, alloc: std.mem.Allocator) !File {
     const root_inode = try Utils.inodeFromRef(
         alloc,
-        io,
         self.file,
         &self.stateless_decomp,
         self.super.inode_start,
         self.super.block_size,
         self.super.root_ref,
     );
-    return .init(alloc, self, root_inode, "");
+    return .init(alloc, self.*, root_inode, "");
 }
 /// Opens a File within the archive.
-pub fn open(self: Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
+pub fn open(self: *Archive, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
-    const root_file = try self.root(alloc, io);
+    var root_file = try self.root(alloc);
     const path = std.mem.trim(u8, filepath, "/");
     if (Utils.pathIsSelf(path))
         return root_file;
     defer root_file.deinit();
     return root_file.open(alloc, io, filepath);
 }
-/// Extract the entire archive contents to the given directory.
-pub fn extract(self: Archive, alloc: std.mem.Allocator, io: Io, extract_dir: []const u8, options: ExtractionOptions) !void {
-    const root_inode = try Utils.inodeFromRef(
-        alloc,
-        io,
-        self.file,
-        &self.stateless_decomp,
-        self.super.inode_start,
-        self.super.block_size,
-        self.super.root_ref,
-    );
-    _ = root_inode;
-    _ = extract_dir;
-    _ = options;
-    return error.TODO;
-}
 
 /// Returns the inode with the given inode number.
 /// Requires that the archive is exportable (has an export lookup table).
-pub fn inode(self: Archive, alloc: std.mem.Allocator, io: Io, num: u32) !Inode {
+pub fn inode(self: *Archive, alloc: std.mem.Allocator, io: Io, num: u32) !Inode {
     if (!self.super.flags.exportable)
         return error.NotExportable;
     const ref = try LookupTable.lookupValue(
@@ -101,7 +83,7 @@ pub fn inode(self: Archive, alloc: std.mem.Allocator, io: Io, num: u32) !Inode {
     );
 }
 /// Returns a value at the given index from the Archive's id (uid/gid) table.
-pub fn idTable(self: Archive, alloc: std.mem.Allocator, io: Io, idx: u32) !u16 {
+pub fn idTable(self: *Archive, alloc: std.mem.Allocator, io: Io, idx: u32) !u16 {
     return LookupTable.lookupValue(
         u16,
         alloc,
@@ -113,6 +95,19 @@ pub fn idTable(self: Archive, alloc: std.mem.Allocator, io: Io, idx: u32) !u16 {
     );
 }
 
+/// Extract the entire archive contents to the given directory.
+pub fn extract(self: *Archive, alloc: std.mem.Allocator, io: Io, extract_dir: []const u8, options: ExtractionOptions) !void {
+    const root_inode = try Utils.inodeFromRef(
+        alloc,
+        self.file,
+        &self.stateless_decomp,
+        self.super.inode_start,
+        self.super.block_size,
+        self.super.root_ref,
+    );
+    return root_inode.extract(alloc, io, self.file, self.super, extract_dir, options);
+}
+
 // Superblock
 
 const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
@@ -131,14 +126,7 @@ pub const Superblock = extern struct {
     mod_time: u32,
     block_size: u32,
     frag_count: u32,
-    compression: enum(u16) {
+    compression: Decomp.Enum,
-        gzip = 1,
-        lzma,
-        lzo,
-        xz,
-        lz4,
-        zstd,
-    },
     block_log: u16,
     flags: packed struct(u16) {
         inode_uncompressed: bool,
@@ -179,3 +167,122 @@ pub const Superblock = extern struct {
             return SuperblockError.InvalidBlockLog;
     }
 };
+
+// Tests
+
+const TestArchive = "testing/LinuxPATest.sfs";
+
+test "Basics" {
+    std.debug.print("Starting test: Basics...\n", .{});
+
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer fil.close(io);
+    var sfs: Archive = try .init(io, fil, 0);
+    defer sfs.deinit(io);
+    try std.testing.expectEqualDeep(sfs.super, LinuxPATestCorrectSuperblock);
+    const root_file = try sfs.root(alloc);
+    defer root_file.deinit();
+}
+
+const TestFile = "Start.exe";
+const TestFileExtractLocation = "testing/Start.exe";
+
+test "ExtractSingleFile" {
+    std.debug.print("Starting test: ExtractSingleFile...\n", .{});
+
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    Io.Dir.cwd().deleteFile(io, TestFileExtractLocation) catch {};
+    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer fil.close(io);
+    var sfs: Archive = try .init(io, fil, 0);
+    defer sfs.deinit(io);
+    var test_fil = try sfs.open(alloc, io, TestFile);
+    defer test_fil.deinit();
+    try test_fil.extract(alloc, io, TestFileExtractLocation, .default);
+    //TODO: validate extracted file.
+}
+
+const TestFullExtractLocation = "testing/TestExtract";
+
+test "ExtractCompleteArchive" {
+    std.debug.print("Starting test: ExtractCompleteArchive...\n", .{});
+
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    Io.Dir.cwd().deleteTree(io, TestFullExtractLocation) catch {};
+    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer fil.close(io);
+    var sfs: Archive = try .init(io, fil, 0);
+    defer sfs.deinit(io);
+    try sfs.extract(alloc, io, TestFullExtractLocation, .default);
+}
+
+test "ExtractCompleteArchiveSingleThreaded" {
+    std.debug.print("Starting test: ExtractCompleteArchive...\n", .{});
+
+    const alloc = std.testing.allocator;
+    const io = std.testing.io;
+
+    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
+    defer fil.close(io);
+    {
+        std.debug.print("First testing using Threaded.global_single_threaded...\n", .{});
+        Io.Dir.cwd().deleteTree(io, TestFullExtractLocation) catch {};
+        var sfs: Archive = try .init(Io.Threaded.global_single_threaded.io(), fil, 0);
+        defer sfs.deinit(Io.Threaded.global_single_threaded.io());
+        try sfs.extract(alloc, Io.Threaded.global_single_threaded.io(), TestFullExtractLocation, .default);
+    }
+    {
+        std.debug.print("Next testing using ExtractionOptions.single_threaded...\n", .{});
+        Io.Dir.cwd().deleteTree(io, TestFullExtractLocation) catch {};
+        var sfs: Archive = try .init(io, fil, 0);
+        defer sfs.deinit(io);
+        try sfs.extract(alloc, io, TestFullExtractLocation, .default_single_threaded);
+    }
+}
+
+const LinuxPATestCorrectSuperblock: Superblock = .{
+    .magic = std.mem.readInt(u32, "hsqs", .little),
+    .inode_count = 2974,
+    .mod_time = 1632696724,
+    .block_size = 131072,
+    .frag_count = 264,
+    .compression = .zstd,
+    .block_log = 17,
+    .flags = .{
+        .inode_uncompressed = false,
+        .data_uncompressed = false,
+        .check = false,
+        .frag_uncompressed = false,
+        .fragment_never = false,
+        .fragment_always = false,
+        .duplicates = true,
+        .exportable = true,
+        .xattr_uncompressed = false,
+        .xattr_never = false,
+        .compression_options = false,
+        .ids_uncompressed = false,
+        ._ = 0,
+    },
+    .id_count = 1,
+    .ver_maj = 4,
+    .ver_min = 0,
+    .root_ref = .{
+        .block_offset = 1363,
+        .block_start = 29237,
+        ._ = 0,
+    },
+    .size = 106841744,
+    .id_start = 106841632,
+    .xattr_start = 106841720,
+    .inode_start = 106778274,
+    .dir_start = 106807998,
+    .frag_start = 106837747,
+    .export_start = 106841602,
+};

src/bin/unsquashfs.zig

@@ -18,7 +18,7 @@ const help_mgs =
     \\  -dx             Don't set xattr values
     \\  -dp             Don't set permissions (includes setting uid & gid owner)
     \\
-    \\  -p <threads>    Specify how many threads to use. If no present or zero, the system's logical cores count is used.
+    \\  -p <threads>    Specify how many threads to use. If not present or zero, the system's logical cores count is used.
     \\  -v              Verbose
     \\
     \\  --force         Force extraction. If the destination already exists, it will be deleted.
@@ -41,29 +41,47 @@ var force: bool = false;
 
 pub fn main(init: std.process.Init) !void {
     const alloc = init.gpa;
-    const io = init.io;
+    // const io = init.io;
+    var evented: Io.Evented = undefined;
+    try evented.init(alloc, .{});
+    const io = evented.io();
+
     var stdout = std.Io.File.stdout();
+    defer stdout.close(io);
     var out = stdout.writer(io, &[0]u8{});
     defer out.interface.flush() catch {};
+
     try handleArgs(init.minimal.args, &out.interface);
     if (archive.len == 0) {
         try out.interface.print("You must provide a squashfs archive\n", .{});
         try out.interface.print(help_mgs, .{});
         return;
     }
+
     var fil = try Io.Dir.cwd().openFile(io, archive, .{}); //TODO: Handle error gracefully.
     defer fil.close(io);
-    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Update when memory size matters. //TODO: Handle error gracefully.
+
+    var arc: squashfs.Archive = try .init(io, fil, offset); //TODO: Handle error gracefully.
     const options: squashfs.ExtractionOptions = .{
-        .threads = if (threads == 0) try std.Thread.getCpuCount() else threads,
+        .single_threaded = threads == 1,
         .verbose = verbose,
         .verbose_writer = if (verbose) &out.interface else null,
         .ignore_xattr = ignore_xattrs,
         .ignore_permissions = ignore_permissions,
     };
+
     if (force)
         try Io.Dir.cwd().deleteTree(io, extLoc);
-    try arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
+    if (threads != 0) {
+        var limited_io = Io.Threaded.init(alloc, .{
+            .async_limit = .limited(threads - 1),
+            .concurrent_limit = .limited(threads - 1),
+            .argv0 = .init(init.minimal.args),
+            .environ = init.minimal.environ,
+        });
+        return arc.extract(alloc, limited_io.io(), extLoc, options); //TODO: Handle error gracefully.
+    }
+    return arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
 }
 
 fn handleArgs(args: std.process.Args, out: *Writer) !void {

src/c.h

@@ -0,0 +1,7 @@
+#include <zstd.h>
+#include <zlib-ng.h>
+#include <lzma.h>
+#ifdef ALLOW_LZO
+#include <lzo/minilzo.h>
+#endif
+#include <lz4.h>

src/decomp.zig

@@ -0,0 +1,87 @@
+const std = @import("std");
+const Io = std.Io;
+
+const options = @import("options");
+
+const Decompressor = @import("util/decompressor.zig");
+
+const zlib = if (options.use_zig_decomp) @import("decomp/zig_zlib.zig") else @import("decomp/c_zlib.zig");
+const lzma = if (options.use_zig_decomp) @import("decomp/zig_lzma.zig") else @import("decomp/c_lzma.zig");
+const lzo = if (options.use_zig_decomp or !options.allow_lzo) void else @import("decomp/c_lzo.zig");
+const xz = if (options.use_zig_decomp) @import("decomp/zig_xz.zig") else @import("decomp/c_xz.zig");
+const lz4 = if (options.use_zig_decomp) void else @import("decomp/c_lz4.zig");
+const zstd = if (options.use_zig_decomp) @import("decomp/zig_zstd.zig") else @import("decomp/c_zstd.zig");
+
+pub const Enum = enum(u16) {
+    gzip = 1,
+    lzma,
+    lzo,
+    xz,
+    lz4,
+    zstd,
+};
+
+pub fn StatelessDecomp(val: Enum) !Decompressor {
+    return switch (val) {
+        .gzip => zlib.stateless_decompressor,
+        .lzma => lzma.stateless_decompressor,
+        .lzo => if (options.use_zig_decomp or !options.allow_lzo)
+            error.LzoUnsupported
+        else
+            lzo.stateless_decompressor,
+        .xz => xz.stateless_decompressor,
+        .lz4 => if (options.use_zig_decomp)
+            error.Lz4Unsupported
+        else
+            lz4.stateless_decompressor,
+        .zstd => zstd.stateless_decompressor,
+    };
+}
+
+pub const Decomp = union(enum) {
+    gzip: zlib,
+    lzma: lzma,
+    lzo: lzo,
+    xz: xz,
+    lz4: lz4,
+    zstd: zstd,
+
+    pub fn init(val: Enum, alloc: std.mem.Allocator, io: Io, block_size: u32) !Decomp {
+        return switch (val) {
+            .gzip => .{ .gzip = if (options.use_zig_decomp) try zlib.init(alloc, io, block_size) else try zlib.init(alloc, io) },
+            .lzma => .{ .lzma = if (options.use_zig_decomp) try lzma.init(alloc, io, block_size) else .{} },
+            .lzo => if (options.use_zig_decomp or !options.allow_lzo) error.LzoUnsupported else .{ .lzo = .{} },
+            .xz => .{ .xz = if (options.use_zig_decomp) try xz.init(alloc, io, block_size) else .{} },
+            .lz4 => if (options.use_zig_decomp) error.Lz4Unsupported else .{ .lz4 = .{} },
+            .zstd => .{ .zstd = if (options.use_zig_decomp) try zstd.init(alloc, io, block_size) else try zstd.init(alloc, io) },
+        };
+    }
+    pub fn deinit(self: *Decomp, alloc: std.mem.Allocator) void {
+        if (options.use_zig_decomp) {
+            switch (self.*) {
+                .gzip => self.gzip.deinit(),
+                .lzma => self.lzma.deinit(),
+                .xz => self.xz.deinit(),
+                .zstd => self.zstd.deinit(),
+                else => {},
+            }
+        } else {
+            switch (self.*) {
+                .gzip => self.gzip.deinit(alloc),
+                .zstd => self.zstd.deinit(alloc),
+                else => {},
+            }
+        }
+    }
+
+    pub fn decompressor(self: *Decomp) *Decompressor {
+        return switch (self.*) {
+            .gzip => &self.gzip.interface,
+            .lzma => &self.lzma.interface,
+            .lzo => if (options.use_zig_decomp or !options.allow_lzo) unreachable else &self.lzo.interface,
+            .xz => &self.xz.interface,
+            .lz4 => if (options.use_zig_decomp) unreachable else &self.lz4.interface,
+            .zstd => &self.zstd.interface,
+        };
+    }
+};

src/decomp/c_lz4.zig

@@ -0,0 +1,17 @@
+const std = @import("std");
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+interface: Decompressor = .{ .decomp_fn = statelessDecomp },
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const out_len: c_int = @bitCast(@as(u32, @truncate(out.len)));
+    const res = c.LZ4_decompress_fast(in.ptr, out.ptr, out_len);
+    if (res < 0) return Error.ReadFailed;
+    return @abs(res);
+}

src/decomp/c_lzma.zig

@@ -0,0 +1,46 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+const Node = std.SinglyLinkedList.Node;
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue(c.lzma_stream);
+
+const Self = @This();
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+interface: Decompressor = .{ .decomp_fn = statelessDecomp },
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var stream: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+    };
+
+    var res = c.lzma_alone_decoder(&stream, stream.avail_out * 2);
+    if (res != c.LZMA_OK) return Error.ReadFailed;
+    while (res == c.LZMA_OK)
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+    if (res != c.LZMA_FINISH) return Error.ReadFailed;
+    return stream.total_out;
+}
+
+// lzma_allocator
+
+// fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
+//     var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+//     return alloc.rawAlloc(size, .@"1", 0);
+// }
+// fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
+//     if (mem_ptr == null) return;
+//     var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+//     alloc.free(@as([*]u8, @ptrCast(mem_ptr.?)));
+// }

src/decomp/c_lzo.zig

@@ -0,0 +1,26 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+const Node = std.SinglyLinkedList.Node;
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue(c.lzma_stream);
+
+const Self = @This();
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+interface: Decompressor = .{ .decomp_fn = statelessDecomp },
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    _ = c.lzo_init();
+    var out_len = out.len;
+    const res = c.lzo1x_decompress_safe(in.ptr, in.len, out.ptr, &out_len, null);
+    if (res != c.LZO_E_OK) return Error.ReadFailed;
+    return out_len;
+}

src/decomp/c_xz.zig

@@ -0,0 +1,47 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+const Node = std.SinglyLinkedList.Node;
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue(c.lzma_stream);
+
+const Self = @This();
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+interface: Decompressor = .{ .decomp_fn = statelessDecomp },
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var stream: c.lzma_stream = .{
+        .next_in = in.ptr,
+        .avail_in = in.len,
+        .next_out = out.ptr,
+        .avail_out = out.len,
+    };
+
+    var res = c.lzma_alone_decoder(&stream, stream.avail_out * 2);
+    if (res != c.LZMA_OK) return Error.ReadFailed;
+    while (res == c.LZMA_OK)
+        res = c.lzma_code(&stream, c.LZMA_RUN);
+    if (res != c.LZMA_FINISH) return Error.ReadFailed;
+    return stream.total_out;
+}
+
+// lzma_allocator
+
+// fn lzmaAlloc(ptr: ?*anyopaque, size: usize, _: usize) callconv(.c) ?*anyopaque {
+//     var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+//     const mem = alloc.alloc(u8, size) catch return null;
+//     return mem.ptr;
+// }
+// fn lzmaFree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
+//     if (mem_ptr == null) return;
+//     var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+//     alloc.free(@as([*]u8, @ptrCast(mem_ptr.?)));
+// }

src/decomp/c_zlib.zig

@@ -0,0 +1,80 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+const Node = std.SinglyLinkedList.Node;
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue(c.zng_stream);
+
+const Self = @This();
+
+interface: Decompressor = .{ .decomp_fn = decomp },
+
+io: Io,
+
+ctx: []c.zng_stream,
+ctx_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io) !Self {
+    const buf = try alloc.alloc(c.zng_stream, 20); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (0..20) |_|
+        try queue.putOne(io, .{});
+
+    return .{
+        .io = io,
+
+        .ctx = buf,
+        .ctx_queue = queue,
+    };
+}
+pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
+    self.ctx_queue.close(self.io);
+    alloc.free(self.ctx);
+}
+
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    if (d == null) {
+        return statelessDecomp(d, alloc, in, out);
+    }
+    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
+
+    var stream = self.ctx_queue.getOne(self.io) catch return Error.ReadFailed;
+    defer self.ctx_queue.putOne(self.io, stream) catch {};
+
+    stream.next_in = in.ptr;
+    stream.avail_in = @truncate(in.len);
+    stream.next_out = out.ptr;
+    stream.avail_out = @truncate(out.len);
+
+    try zlibDecomp(&stream);
+
+    return stream.total_out;
+}
+
+inline fn zlibDecomp(stream: *c.zng_stream) !void {
+    _ = c.zng_inflateReset(stream);
+
+    const res = c.zng_inflate(stream, c.Z_FULL_FLUSH);
+    if (res != c.Z_OK) return Error.ReadFailed;
+}
+
+// Stateless
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var stream: c.zng_stream = .{
+        .next_in = in.ptr,
+        .avail_in = @truncate(in.len),
+        .next_out = out.ptr,
+        .avail_out = @truncate(out.len),
+    };
+    try zlibDecomp(&stream);
+    return stream.total_out;
+}

src/decomp/c_zstd.zig

@@ -0,0 +1,69 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+const Node = std.SinglyLinkedList.Node;
+
+const c = @import("c");
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue(?*c.ZSTD_DCtx);
+
+const Self = @This();
+
+interface: Decompressor = .{ .decomp_fn = decomp },
+
+io: Io,
+
+ctx: []?*c.ZSTD_DCtx,
+ctx_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io) !Self {
+    const buf = try alloc.alloc(?*c.ZSTD_DCtx, 20); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (0..20) |_|
+        try queue.putOne(io, c.ZSTD_createDCtx());
+
+    return .{
+        .io = io,
+
+        .ctx = buf,
+        .ctx_queue = queue,
+    };
+}
+pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
+    self.ctx_queue.close(self.io);
+    for (self.ctx) |ctx|
+        _ = c.ZSTD_freeDCtx(ctx);
+    alloc.free(self.ctx);
+}
+
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    if (d == null) {
+        return statelessDecomp(d, alloc, in, out);
+    }
+    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
+
+    const ctx = self.ctx_queue.getOne(self.io) catch return Error.ReadFailed;
+    defer self.ctx_queue.putOne(self.io, ctx) catch {};
+
+    _ = c.ZSTD_DCtx_reset(ctx, c.ZSTD_reset_session_only);
+
+    const res = c.ZSTD_decompressDCtx(ctx, out.ptr, out.len, in.ptr, in.len);
+    if (c.ZSTD_isError(res) != 0)
+        return Error.ReadFailed;
+    return res;
+}
+
+// Stateless
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+fn statelessDecomp(_: ?*Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const res = c.ZSTD_decompress(out.ptr, out.len, in.ptr, in.len);
+    if (c.ZSTD_isError(res) != 0)
+        return Error.ReadFailed;
+    return res;
+}

src/decomp/lzma.zig

@@ -1,86 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const lzma = std.compress.lzma;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList = .{},
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        var buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return lzmaDecomp(alloc, &buf, in, out) catch |err| return switch (err) {
-            error.OutOfMemory => Error.OutOfMemory,
-            else => Error.ReadFailed,
-        };
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .node = .{}, .buf = try self.alloc.alloc(u8, self.block_size) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node.?);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return lzmaDecomp(self.alloc, &buf.buf, in, out) catch |err| {
-        // self.err = err;
-        return switch (err) {
-            error.OutOfMemory => Error.OutOfMemory,
-            else => Error.ReadFailed,
-        };
-    };
-}
-
-inline fn lzmaDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try lzma.Decompress.initOptions(&rdr, alloc, buffer.*, .{ .allow_incomplete = true }, 3 * 1024 * 1024);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return lzmaDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/xz.zig

@@ -1,80 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const xz = std.compress.xz;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList = .{},
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        var buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return xzDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .node = .{}, .buf = try self.alloc.alloc(u8, self.block_size) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node.?);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return xzDecomp(self.alloc, &buf.buf, in, out) catch {
-        // self.err = err;
-        return Error.ReadFailed;
-    };
-}
-
-inline fn xzDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = try xz.Decompress.init(&rdr, alloc, buffer.*);
-    defer {
-        buffer.* = d.takeBuffer();
-        d.deinit();
-    }
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var buf = try alloc.alloc(u8, in.len);
-    defer alloc.free(buf);
-    return xzDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
-}

src/decomp/zig_lzma.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const lzma = std.compress.lzma;
+const Node = std.SinglyLinkedList.Node;
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = Io.Queue([]u8);
+
+const Self = @This();
+
+const Buffer = struct {
+    node: Node,
+    buf: []u8,
+};
+
+interface: Decompressor = .{ .decomp_fn = decomp },
+
+alloc: std.mem.Allocator,
+io: Io,
+
+block_size: u32,
+buf: [][]u8,
+buf_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
+    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (0..20) |_|
+        try queue.putOne(io, try alloc.alloc(u8, block_size));
+
+    return .{
+        .alloc = alloc,
+        .io = io,
+
+        .block_size = block_size,
+        .buf = buf,
+        .buf_queue = queue,
+    };
+}
+pub fn deinit(self: *Self) void {
+    self.buf_queue.close(self.io);
+    for (self.buf) |buf|
+        self.alloc.free(buf);
+    self.alloc.free(self.buf);
+}
+
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    if (d == null) {
+        return statelessDecomp(d, alloc, in, out);
+    }
+    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
+
+    var buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
+    defer self.buf_queue.putOne(self.io, buf) catch {};
+
+    return lzmaDecomp(self.alloc, &buf, in, out) catch return Error.ReadFailed;
+}
+
+inline fn lzmaDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
+    var rdr: Reader = .fixed(in);
+    var d = try lzma.Decompress.initOptions(&rdr, alloc, buffer.*, .{}, in.len * 2);
+    defer {
+        buffer.* = d.takeBuffer();
+        d.deinit();
+    }
+
+    return d.reader.readSliceShort(out);
+}
+
+// Stateless
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+fn statelessDecomp(_: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var buf = try alloc.alloc(u8, in.len);
+    defer alloc.free(buf);
+    return lzmaDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
+}

src/decomp/zig_xz.zig

@@ -0,0 +1,81 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const xz = std.compress.xz;
+const Node = std.SinglyLinkedList.Node;
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = Io.Queue([]u8);
+
+const Self = @This();
+
+const Buffer = struct {
+    node: Node,
+    buf: []u8,
+};
+
+interface: Decompressor = .{ .decomp_fn = decomp },
+
+alloc: std.mem.Allocator,
+io: Io,
+
+block_size: u32,
+buf: [][]u8,
+buf_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
+    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (0..20) |_|
+        try queue.putOne(io, try alloc.alloc(u8, block_size));
+
+    return .{
+        .alloc = alloc,
+        .io = io,
+
+        .block_size = block_size,
+        .buf = buf,
+        .buf_queue = queue,
+    };
+}
+pub fn deinit(self: *Self) void {
+    self.buf_queue.close(self.io);
+    for (self.buf) |buf|
+        self.alloc.free(buf);
+    self.alloc.free(self.buf);
+}
+
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    if (d == null) {
+        return statelessDecomp(d, alloc, in, out);
+    }
+    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
+
+    var buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
+    defer self.buf_queue.putOne(self.io, buf) catch {};
+
+    return xzDecomp(self.alloc, &buf, in, out) catch return Error.ReadFailed;
+}
+
+inline fn xzDecomp(alloc: std.mem.Allocator, buffer: *[]u8, in: []u8, out: []u8) !usize {
+    var rdr: Reader = .fixed(in);
+    var d = try xz.Decompress.init(&rdr, alloc, buffer.*);
+    defer {
+        buffer.* = d.takeBuffer();
+        d.deinit();
+    }
+
+    return d.reader.readSliceShort(out);
+}
+
+// Stateless
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+fn statelessDecomp(_: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    var buf = try alloc.alloc(u8, in.len);
+    defer alloc.free(buf);
+    return xzDecomp(alloc, &buf, in, out) catch return Error.ReadFailed;
+}

src/decomp/zig_zlib.zig

@@ -0,0 +1,77 @@
+const std = @import("std");
+const Io = std.Io;
+const flate = std.compress.flate;
+const Node = std.SinglyLinkedList.Node;
+const Reader = Io.Reader;
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = Io.Queue([]u8);
+
+const Self = @This();
+
+const Buffer = struct {
+    node: Node,
+    buf: []u8,
+};
+
+interface: Decompressor = .{ .decomp_fn = decomp },
+
+alloc: std.mem.Allocator,
+io: Io,
+
+block_size: u32,
+buf: [][]u8,
+buf_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
+    const buf = try alloc.alloc([]u8, 20); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (0..20) |_|
+        try queue.putOne(io, try alloc.alloc(u8, block_size));
+
+    return .{
+        .alloc = alloc,
+        .io = io,
+
+        .block_size = block_size,
+        .buf = buf,
+        .buf_queue = queue,
+    };
+}
+pub fn deinit(self: *Self) void {
+    self.buf_queue.close(self.io);
+    for (self.buf) |buf|
+        self.alloc.free(buf);
+    self.alloc.free(self.buf);
+}
+
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    if (d == null) {
+        return statelessDecomp(d, alloc, in, out);
+    }
+    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
+
+    const buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
+    defer self.buf_queue.putOne(self.io, buf) catch {};
+
+    return zlibDecomp(buf, in, out);
+}
+
+inline fn zlibDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
+    var rdr: Reader = .fixed(in);
+    var d = flate.Decompress.init(&rdr, .zlib, buffer);
+
+    return d.reader.readSliceShort(out);
+}
+
+// Stateless
+
+pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
+
+fn statelessDecomp(_: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    const buf = try alloc.alloc(u8, out.len);
+    defer alloc.free(buf);
+    return zlibDecomp(buf, in, out);
+}

src/decomp/zig_zstd.zig

@@ -1,58 +1,58 @@
 const std = @import("std");
+const Io = std.Io;
 const Reader = std.Io.Reader;
 const zstd = std.compress.zstd;
-const Node = std.SinglyLinkedList.Node;
 
 const Decompressor = @import("../util/decompressor.zig");
 const Error = Decompressor.Error;
 
-const Self = @This();
+const Queue = std.Io.Queue([]u8);
 
-const Buffer = struct {
+const Self = @This();
-    node: Node,
-    buf: []u8,
-};
 
 interface: Decompressor = .{ .decomp_fn = decomp },
 
 alloc: std.mem.Allocator,
+io: Io,
 
 block_size: u32,
-buffers: std.ArrayList(Buffer),
+buf: [][]u8,
-buffer_queue: std.SinglyLinkedList = .{},
+buf_queue: Queue,
+
+pub fn init(alloc: std.mem.Allocator, io: Io, block_size: u32) !Self {
+    const buf = try alloc.alloc([]u8, 5); // TODO: Choose a better number instead of a random one.
+    var queue: Queue = .init(buf);
+    for (buf) |_|
+        try queue.putOne(io, try alloc.alloc(u8, block_size + zstd.block_size_max));
 
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
     return .{
         .alloc = alloc,
+        .io = io,
 
         .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
+        .buf = buf,
+        .buf_queue = queue,
     };
 }
-pub fn deinit(self: Self) void {
+pub fn deinit(self: *Self) void {
-    for (self.buffers) |buf|
+    self.buf_queue.close(self.io);
+    for (self.buf) |buf|
         self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
+    self.alloc.free(self.buf);
 }
 
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+fn decomp(d: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
     if (d == null) {
         const buf = try alloc.alloc(u8, in.len * 2);
         defer alloc.free(buf);
         return zstdDecomp(buf, in, out);
     }
     var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-    const buf_node = self.buffer_queue.popFirst();
+
-    var buf: *Buffer = undefined;
+    const buf = self.buf_queue.getOne(self.io) catch return Error.ReadFailed;
-    if (buf_node == null) {
+    defer self.buf_queue.putOne(self.io, buf) catch {};
-        const new_buf = try self.buffers.addOne(self.alloc);
+
-        new_buf.* = .{ .node = .{}, .buf = try self.alloc.alloc(u8, self.block_size + zstd.block_size_max) };
+    return zstdDecomp(buf, in, out);
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node.?);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return zstdDecomp(buf.buf, in, out);
 }
 
 inline fn zstdDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
@@ -66,7 +66,7 @@ inline fn zstdDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
 
 pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
 
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+fn statelessDecomp(_: ?*Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
     const buf = try alloc.alloc(u8, out.len + zstd.block_size_max);
     defer alloc.free(buf);
     return zstdDecomp(buf, in, out);

src/decomp/zlib.zig

@@ -1,73 +0,0 @@
-const std = @import("std");
-const Reader = std.Io.Reader;
-const flate = std.compress.flate;
-const Node = std.SinglyLinkedList.Node;
-
-const Decompressor = @import("../util/decompressor.zig");
-const Error = Decompressor.Error;
-
-const Self = @This();
-
-const Buffer = struct {
-    node: Node,
-    buf: []u8,
-};
-
-interface: Decompressor = .{ .decomp_fn = decomp },
-
-alloc: std.mem.Allocator,
-
-block_size: u32,
-buffers: std.ArrayList(Buffer),
-buffer_queue: std.SinglyLinkedList = .{},
-
-pub fn init(alloc: std.mem.Allocator, block_size: u32) !Self {
-    return .{
-        .alloc = alloc,
-
-        .block_size = block_size,
-        .buffers = try .initCapacity(alloc, 5),
-    };
-}
-pub fn deinit(self: Self) void {
-    for (self.buffers) |buf|
-        self.alloc.free(buf);
-    self.buffers.deinit(self.alloc);
-}
-
-fn decomp(d: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    if (d == null) {
-        const buf = try alloc.alloc(u8, in.len * 2);
-        defer alloc.free(buf);
-        return zlibDecomp(buf, in, out);
-    }
-    var self: *Self = @fieldParentPtr("interface", @constCast(d.?));
-    const buf_node = self.buffer_queue.popFirst();
-    var buf: *Buffer = undefined;
-    if (buf_node == null) {
-        const new_buf = try self.buffers.addOne(self.alloc);
-        new_buf.* = .{ .node = .{}, .buf = try self.alloc.alloc(u8, self.block_size) };
-        buf = new_buf;
-    } else {
-        buf = @fieldParentPtr("node", buf_node.?);
-    }
-    defer self.buffer_queue.prepend(&buf.node);
-    return zlibDecomp(buf.buf, in, out);
-}
-
-inline fn zlibDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
-    var rdr: Reader = .fixed(in);
-    var d = flate.Decompress.init(&rdr, .zlib, buffer);
-
-    return d.reader.readSliceShort(out);
-}
-
-// Stateless
-
-pub const stateless_decompressor: Decompressor = .{ .decomp_fn = statelessDecomp };
-
-fn statelessDecomp(_: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const buf = try alloc.alloc(u8, in.len * 2);
-    defer alloc.free(buf);
-    return zlibDecomp(buf, in, out);
-}

src/directory.zig

@@ -3,6 +3,8 @@ const Reader = std.Io.Reader;
 
 const Inode = @import("inode.zig");
 
+pub const Error = error{OutOfMemory} || Reader.Error;
+
 const DirEntry = @This();
 
 block_start: u32,
@@ -14,7 +16,7 @@ pub fn deinit(self: DirEntry, alloc: std.mem.Allocator) void {
     alloc.free(self.name);
 }
 
-pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) ![]DirEntry {
+pub fn readDirectory(alloc: std.mem.Allocator, rdr: *Reader, size: u32) Error![]DirEntry {
     var hdr: Header = undefined;
     var raw: RawEntry = undefined;
     var out: std.ArrayList(DirEntry) = try .initCapacity(alloc, 30);

src/file.zig

@@ -10,7 +10,6 @@ const Inode = @import("inode.zig");
 const DataExtractor = @import("util/data_extractor.zig");
 const Decompressor = @import("util/decompressor.zig");
 const MetadataReader = @import("util/metadata.zig");
-const SharedCache = @import("util/shared_cache.zig");
 
 const File = @This();
 
@@ -35,24 +34,23 @@ pub fn init(alloc: std.mem.Allocator, archive: Archive, in: Inode, name: []const
         .name = new_name,
     };
 }
-pub fn fromDirEntry(alloc: std.mem.Allocator, io: Io, archive: Archive, ent: DirEntry) !File {
+pub fn fromDirEntry(alloc: std.mem.Allocator, archive: *Archive, ent: DirEntry) !File {
-    var rdr = try archive.file.readerAt(io, archive.super.inode_start + ent.block_start, &[0]u8{});
+    var rdr = archive.file.readerAt(archive.super.inode_start + ent.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, &archive.stateless_decomp);
+    var meta: MetadataReader = .init(alloc, &rdr, &archive.stateless_decomp);
     try meta.interface.discardAll(ent.block_offset);
 
     var in: Inode = try .read(alloc, &meta.interface, archive.super.block_size);
     errdefer in.deinit(alloc);
-    return .init(alloc, archive, in, ent.name);
+    return .init(alloc, archive.*, in, ent.name);
 }
 pub fn deinit(self: File) void {
     self.alloc.free(self.name);
     self.inode.deinit(self.alloc);
 }
 
-pub fn open(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
+pub fn open(self: *File, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
     const entries = try self.inode.readDirectory(
         alloc,
-        io,
         self.archive.file,
         &self.archive.stateless_decomp,
         self.archive.super.dir_start,
@@ -77,7 +75,7 @@ pub fn open(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8)
         }
     } else return Error.FileNotFound;
 
-    const first_elem_file = try fromDirEntry(alloc, io, self.archive, search_slice[idx]);
+    var first_elem_file = try fromDirEntry(alloc, &self.archive, search_slice[idx]);
     if (first_element.len == path.len)
         return first_elem_file;
     defer first_elem_file.deinit();

src/frag.zig

@@ -1,7 +1,85 @@
+const std = @import("std");
+const Io = std.Io;
+
 const BlockSize = @import("inode_data/file.zig").BlockSize;
+const LookupTable = @import("lookup_table.zig");
+const Decompressor = @import("util/decompressor.zig");
+const MetadataReader = @import("util/metadata.zig");
+const OffsetFile = @import("util/offset_file.zig");
+
+const FragManager = @This();
 
 pub const FragEntry = extern struct {
     start: u64,
     size: BlockSize,
     _: u32,
 };
+
+alloc: std.mem.Allocator,
+fil: OffsetFile,
+decomp: *Decompressor,
+block_size: u32,
+
+entries: []FragEntry,
+
+frag_cache: std.array_hash_map.Auto(u32, []u8),
+cache_mut: std.Io.RwLock = .init,
+
+pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *Decompressor, frag_start: u64, frag_num: u32, block_size: u32) !FragManager {
+    const first_offset: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[frag_start .. frag_start + 8]), .little);
+
+    var rdr = fil.readerAt(first_offset);
+    var meta: MetadataReader = .init(alloc, &rdr, decomp);
+
+    const entries = try alloc.alloc(FragEntry, frag_num);
+    errdefer alloc.free(entries);
+
+    try meta.interface.readSliceEndian(FragEntry, entries, .little);
+
+    return .{
+        .alloc = alloc,
+        .fil = fil,
+        .decomp = decomp,
+        .block_size = block_size,
+
+        .entries = entries,
+
+        .frag_cache = .empty,
+    };
+}
+pub fn deinit(self: *FragManager, io: Io) void {
+    self.cache_mut.lockUncancelable(io);
+    self.alloc.free(self.entries);
+    for (self.frag_cache.values()) |v|
+        self.alloc.free(v);
+    self.frag_cache.deinit(self.alloc);
+}
+
+pub fn get(self: *FragManager, io: Io, idx: u32) ![]u8 {
+    {
+        try self.cache_mut.lockShared(io);
+        defer self.cache_mut.unlockShared(io);
+        if (self.frag_cache.contains(idx))
+            return self.frag_cache.get(idx).?;
+    }
+
+    try self.cache_mut.lock(io);
+    defer self.cache_mut.unlock(io);
+
+    if (self.frag_cache.contains(idx))
+        return self.frag_cache.get(idx).?;
+
+    const entry = self.entries[idx];
+
+    const out = try self.alloc.alloc(u8, if (entry.size.uncompressed) entry.size.size else self.block_size);
+
+    if (entry.size.uncompressed) {
+        @memcpy(out, self.fil.map.memory[entry.start .. entry.start + entry.size.size]);
+    } else {
+        @branchHint(.likely);
+        _ = try self.decomp.Decompress(self.alloc, self.fil.map.memory[entry.start .. entry.start + entry.size.size], out);
+    }
+
+    try self.frag_cache.put(self.alloc, idx, out);
+    return out;
+}

src/inode.zig

@@ -5,19 +5,21 @@ const Reader = std.Io.Reader;
 const Io = std.Io;
 
 const Archive = @import("archive.zig");
+const Decomp = @import("decomp.zig").Decomp;
 const DirEntry = @import("directory.zig");
 const ExtractionOptions = @import("options.zig");
 const FragEntry = @import("frag.zig").FragEntry;
+const FragManager = @import("frag.zig");
 const dir = @import("inode_data/dir.zig");
 const file = @import("inode_data/file.zig");
 const misc = @import("inode_data/misc.zig");
 const LookupTable = @import("lookup_table.zig");
+const CachedTable = LookupTable.CachedTable;
 const DataExtractor = @import("util/data_extractor.zig");
 const DataReader = @import("util/data_reader.zig");
 const Decompressor = @import("util/decompressor.zig");
 const MetadataReader = @import("util/metadata.zig");
 const OffsetFile = @import("util/offset_file.zig");
-const SharedCache = @import("util/shared_cache.zig");
 const XattrTable = @import("xattr_table.zig");
 
 const Inode = @This();
@@ -61,53 +63,53 @@ pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
 // Utility Functions
 
 /// Read the directory entries
-pub fn readDirectory(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64) ![]DirEntry {
+pub fn readDirectory(self: Inode, alloc: std.mem.Allocator, fil: OffsetFile, decomp: *Decompressor, dir_offset: u64) ![]DirEntry {
     return switch (self.data) {
-        .dir => |d| readDirFromData(alloc, io, fil, decomp, dir_offset, d),
+        .dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
-        .ext_dir => |d| readDirFromData(alloc, io, fil, decomp, dir_offset, d),
+        .ext_dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
         else => Error.NotDirectory,
     };
 }
-fn readDirFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64, d: anytype) ![]DirEntry {
+fn readDirFromData(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *Decompressor, dir_offset: u64, d: anytype) ![]DirEntry {
-    var rdr = try fil.readerAt(io, dir_offset + d.block_start, &[0]u8{});
+    var rdr = fil.readerAt(dir_offset + d.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
+    var meta: MetadataReader = .init(alloc, &rdr, decomp);
     try meta.interface.discardAll(d.block_offset);
 
     return DirEntry.readDirectory(alloc, &meta.interface, d.size);
 }
 /// Get a reader for a regular file's data.
-pub fn dataReader(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataReader {
+pub fn dataReader(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, block_size: u32, frag_block: ?[]u8) !DataReader {
     return switch (self.data) {
-        .file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
+        .file => |f| getReaderFromData(alloc, io, fil, decomp, block_size, frag_block, f),
-        .ext_file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
+        .ext_file => |f| getReaderFromData(alloc, io, fil, decomp, block_size, frag_block, f),
         else => Error.NotRegularFile,
     };
 }
-fn getReaderFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataReader {
+fn getReaderFromData(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, block_size: u32, frag_block: ?[]u8, d: anytype) !DataReader {
-    const ext: DataReader = .init(alloc, io, fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+    const ext: DataReader = .init(alloc, io, fil, decomp, block_size, d.size, d.block_start, d.blocks);
     if (d.frag_block_offset == 0xFFFFFFFF) {
-        // TODO:
+        if (frag_block == null) return error.FragBlockNotProvided;
-        return error.TODO;
+        ext.addFrag(d.frag_block_offset, frag_block.?);
     }
     return ext;
 }
 /// Get an extractor for a regular file's data.
-pub fn dataExtractor(self: Inode, fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32) !DataExtractor {
+pub fn dataExtractor(self: Inode, fil: OffsetFile, decomp: *Decompressor, block_size: u32, frag_block: ?[]u8) !DataExtractor {
     return switch (self.data) {
-        .file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
+        .file => |f| getExtractorFromData(fil, decomp, block_size, frag_block, f),
-        .ext_file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
+        .ext_file => |f| getExtractorFromData(fil, decomp, block_size, frag_block, f),
         else => Error.NotRegularFile,
     };
 }
-fn getExtractorFromData(fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataExtractor {
+fn getExtractorFromData(fil: OffsetFile, decomp: *Decompressor, block_size: u32, frag_block: ?[]u8, d: anytype) !DataExtractor {
-    const ext: DataExtractor = .init(fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+    const ext: DataExtractor = .init(fil, decomp, block_size, d.size, d.block_start, d.blocks);
     if (d.frag_block_offset == 0xFFFFFFFF) {
-        // TODO:
+        if (frag_block == null) return error.FragBlockNotProvided;
-        return error.TODO;
+        ext.addFrag(d.frag_block_offset, frag_block.?);
     }
     return ext;
 }
-// Get a symlink's target path
+/// Get a symlink's target path
 pub fn symlinkTarget(self: Inode) ![]const u8 {
     return switch (self.data) {
         .symlink => |s| s.target,
@@ -115,28 +117,17 @@ pub fn symlinkTarget(self: Inode) ![]const u8 {
         else => Error.NotSymlink,
     };
 }
-// Get inode's gid
+/// Get inode's gid
-pub fn gid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
+pub fn gid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, id_table_start: u64) !u16 {
     return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.gid_idx);
 }
-// Get inode's uid
+/// Get inode's uid
-pub fn uid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, id_table_start: u64) !u16 {
+pub fn uid(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, id_table_start: u64) !u16 {
     return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.uid_idx);
 }
+/// Get the inode's xattr values as an index into the Archive's xattr table.
+/// Returns error.NoXattr if the inode doesn't have extended attributes.
 pub fn xattrIndex(self: Inode) !u32 {
-    return switch (self.data) {
-        .ext_dir => |e| e.xattr_idx,
-        .ext_file => |e| e.xattr_idx,
-        .ext_symlink => |e| e.xattr_idx,
-        .ext_block_dev => |e| e.xattr_idx,
-        .ext_char_dev => |e| e.xattr_idx,
-        .ext_fifo => |e| e.xattr_idx,
-        .ext_socket => |e| e.xattr_idx,
-        else => Error.NotExtended,
-    };
-}
-// Get an inode's xattr values. If the inode does not have xattr values (including if the inode is not an extended type), an empty slice is returned.
-pub fn xattrValues(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, xattr_table_start: u64) ![]XattrTable.XattrOwned {
     const idx = switch (self.data) {
         .ext_dir => |e| e.xattr_idx,
         .ext_file => |e| e.xattr_idx,
@@ -145,9 +136,14 @@ pub fn xattrValues(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFil
         .ext_char_dev => |e| e.xattr_idx,
         .ext_fifo => |e| e.xattr_idx,
         .ext_socket => |e| e.xattr_idx,
-        else => return &[0]XattrTable.XattrOwned{},
+        else => return error.NoXattr,
     };
-    if (idx == 0xFFFFFFFF) return &[0]XattrTable.XattrOwned{};
+    if (idx == 0xFFFFFFFF) return error.NoXattr;
+    return idx;
+}
+// Get an inode's xattr values. If the inode does not have xattr values (including if the inode is not an extended type), an empty slice is returned.
+pub fn xattrValues(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, xattr_table_start: u64) ![]XattrTable.XattrOwned {
+    const idx = self.xattrIndex() catch &[0]XattrTable.XattrOwned{};
     return XattrTable.statelessLookup(alloc, io, decomp, fil, xattr_table_start, idx);
 }
 
@@ -163,7 +159,7 @@ pub const Error = error{
 pub const Ref = packed struct(u64) {
     block_offset: u16,
     block_start: u32,
-    _: u16,
+    _: u16 = 0,
 };
 
 pub const Type = enum(u16) {
@@ -211,9 +207,53 @@ pub const Header = extern struct {
 
 // Extract
 
-const FileRet = struct {
+const ExtractError = error{ MknodFailed, CannotSetXattr } || DataExtractor.Error || DirEntry.Error ||
-    file: Io.File,
+    Decompressor.Error || Io.File.Atomic.InitError || Io.File.Atomic.LinkError || Io.Dir.SymLinkError;
+const PathRet = struct {
+    path: []const u8,
     inode: Inode,
+    origin: bool,
+
+    fn deinit(self: PathRet, alloc: std.mem.Allocator) void {
+        if (self.origin) return;
+        alloc.free(self.path);
+        self.inode.deinit(alloc);
+    }
+    fn setMetadata(self: PathRet, alloc: std.mem.Allocator, io: Io, id_table: *CachedTable(u16), xattr_table: ?*XattrTable, options: ExtractionOptions) !void {
+        var fil = try Io.Dir.cwd().openFile(io, self.path, .{});
+        defer fil.close(io);
+
+        const inode = self.inode;
+
+        if (!options.ignore_permissions) {
+            try fil.setPermissions(io, @enumFromInt(inode.hdr.permissions));
+            try fil.setOwner(io, try id_table.get(io, inode.hdr.uid_idx), try id_table.get(io, inode.hdr.gid_idx));
+        }
+        if (xattr_table != null) {
+            const idx = inode.xattrIndex() catch return;
+
+            const xattrs = try xattr_table.?.get(alloc, io, idx);
+            defer {
+                for (xattrs) |x|
+                    x.deinit(alloc);
+                alloc.free(xattrs);
+            }
+
+            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{self.path}, 0);
+            defer alloc.free(sentinel_path);
+            for (xattrs) |x| {
+                const xattr_ret = std.os.linux.fsetxattr(fil.handle, x.key, x.value.ptr, x.value.len, 0);
+                if (xattr_ret != 0)
+                    return ExtractError.CannotSetXattr;
+            }
+        }
+    }
+};
+fn DirCompare(_: void, a: PathRet, b: PathRet) std.math.Order {
+    return std.math.order(std.mem.count(u8, a.path, "/"), std.mem.count(u8, b.path, "/"));
+}
+const ExtractReturnUnion = union(enum) {
+    path_ret: ExtractError!PathRet,
 };
 const Tables = struct {
     id: LookupTable.CachedTable(u16),
@@ -221,299 +261,373 @@ const Tables = struct {
     xattr: XattrTable,
 };
 
-pub fn extract(self: Inode, alloc: std.mem.Allocator, io: Io, fil: OffsetFile, super: Archive.Superblock, path: []const u8, options: ExtractionOptions) !void {
+/// Extracts the given inode to the given path. If the inode not a directory, the given path must not exist.
-    var decomp = switch (super.compression) {
+/// If the inode is a directory the path must not exist or be a directory.
-        .gzip => try @import("decomp/zlib.zig").init(alloc, super.block_size),
+pub fn extract(
-        .lzma => try @import("decomp/lzma.zig").init(alloc, super.block_size),
+    self: Inode,
-        .xz => try @import("decomp/xz.zig").init(alloc, super.block_size),
+    alloc: std.mem.Allocator,
-        .zstd => try @import("decomp/zstd.zig").init(alloc, super.block_size),
+    io: Io,
+    fil: OffsetFile,
+    super: Archive.Superblock,
+    filepath: []const u8,
+    options: ExtractionOptions,
+) !void {
+    const path = std.mem.trimEnd(u8, filepath, "/");
+
+    var decomp_base: Decompressor = try @import("decomp.zig").StatelessDecomp(super.compression); // TODO: Replace with actual Decomp value to share states & caches for efficiency.
+    const decomp = &decomp_base;
+
+    var frag_mgr: FragManager = try .init(alloc, fil, decomp, super.frag_start, super.frag_count, super.block_size);
+    defer frag_mgr.deinit(io);
+
+    if (options.single_threaded)
+        return self.extractSinglethreaded(alloc, io, fil, super, path, options, decomp, &frag_mgr);
+
+    var sel_buf: [10]ExtractReturnUnion = undefined;
+    var sel: Io.Select(ExtractReturnUnion) = .init(io, &sel_buf);
+    defer sel.cancelDiscard();
+
+    var loop = io.async(finishLoop, .{ alloc, io, fil, decomp, super, options, &sel });
+
+    sel.async(.path_ret, extractRealAsync, .{ self, alloc, io, fil, super, decomp, &sel, &frag_mgr, path, true });
+
+    try loop.await(io);
+}
+fn extractRealAsync(
+    self: Inode,
+    alloc: std.mem.Allocator,
+    io: Io,
+    fil: OffsetFile,
+    super: Archive.Superblock,
+    decomp: *Decompressor,
+    sel: *Io.Select(ExtractReturnUnion),
+    frag_mgr: *FragManager,
+    path: []const u8,
+    origin: bool,
+) ExtractError!PathRet {
+    errdefer {
+        if (!origin) {
+            self.deinit(alloc);
+            alloc.free(path);
+        }
+    }
+    switch (self.hdr.inode_type) {
+        .dir, .ext_dir => {
+            try Io.Dir.cwd().createDir(io, path, @enumFromInt(0o777));
+
+            const entries = self.readDirectory(alloc, fil, decomp, super.dir_start) catch |err| switch (err) {
+                Error.NotDirectory, Error.NotExtended, Error.NotRegularFile, Error.NotSymlink => unreachable,
+                else => |e| return e,
+            };
+            defer {
+                for (entries) |e|
+                    e.deinit(alloc);
+                alloc.free(entries);
+            }
+
+            for (entries) |e| {
+                const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", e.name });
+                errdefer alloc.free(new_path);
+
+                var rdr = fil.readerAt(super.inode_start + e.block_start);
+                var meta: MetadataReader = .init(alloc, &rdr, decomp);
+                try meta.interface.discardAll(e.block_offset);
+
+                const new_inode = try read(alloc, &meta.interface, super.block_size);
+                errdefer new_inode.deinit(alloc);
+
+                sel.async(.path_ret, extractRealAsync, .{ new_inode, alloc, io, fil, super, decomp, sel, frag_mgr, new_path, false });
+            }
+        },
+        .file, .ext_file => {
+            var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{ .make_path = true });
+            defer atomic.deinit(io);
+
+            var ext: DataExtractor = switch (self.data) {
+                .file => |f| blk: {
+                    var ext: DataExtractor = .init(fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
+                    if (f.frag_idx != 0xFFFFFFFF)
+                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
+                    break :blk ext;
+                },
+                .ext_file => |f| blk: {
+                    var ext: DataExtractor = .init(fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
+                    if (f.frag_idx != 0xFFFFFFFF)
+                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
+                    break :blk ext;
+                },
                 else => unreachable,
             };
-    defer decomp.deinit();
 
-    var frag_table: LookupTable.CachedTable(FragEntry) = .init(alloc, fil, &decomp.interface, super.frag_start, super.frag_count);
+            try ext.extractAsync(alloc, io, atomic.file);
-    defer frag_table.deinit(io);
 
-    var group: Io.Group = .init;
+            try atomic.link(io);
-    defer group.cancel(io);
-    var que: Io.Queue(FileRet) = .init(&[1]FileRet{undefined} ** 12);
-    defer que.close(io);
-
-    switch (self.hdr.inode_type) {
-        .dir, .ext_dir => group.async(io, extractDir, .{
-            self,
-            alloc,
-            io,
-            fil,
-            &decomp.interface,
-            &frag_table,
-            super.block_size,
-            super.dir_start,
-            path,
-            options,
-            &que,
-        }),
-        .file, .ext_file => group.async(io, extractRegFile, .{
-            self,
-            alloc,
-            io,
-            file,
-            &decomp.interface,
-            &frag_table,
-            super.block_size,
-            path,
-            options,
-            &que,
-        }),
-        .symlink, .ext_symlink => group.async(Io, extractSymlink, .{ self, io, path, options, &que }),
-        else => group.async(io, extractDevice, .{ self, alloc, io, super, path, options, &que }),
-    }
-
-    var id_table: LookupTable.CachedTable(u16) = .init(alloc, fil, decomp, super.id_start, super.id_count);
-    defer id_table.deinit(io);
-    var xattr_table: XattrTable = try .init(alloc, io, fil, decomp, super.xattr_start);
-    defer xattr_table.deinit(io);
-
-    for (que.getOne(io)) |res| {
-        const ret = res catch break;
-
-        const inode: Inode = ret.inode;
-        defer inode.deinit(alloc);
-        const ret_file: Io.File = ret.file;
-        defer ret_file.close(io);
-
-        if (!options.ignore_xattr) {
-            if (inode.xattrIndex()) |idx| {
-                const xattrs = try xattr_table.get(io, idx);
-                for (xattrs) |x| {
-                    // TODO: Check error.
-                    const xattr_res = std.os.linux.fsetxattr(ret_file.handle, x.key, x.value.ptr, x.value.len, 0);
-                    if (xattr_res != 0 and options.verbose)
-                        options.verbose_writer.?.print("setxattr failed with code: {}\n", .{xattr_res}) catch {};
-                }
-            }
-        }
-        if (!options.ignore_permissions) {
-            try ret_file.setPermissions(io, inode.hdr.permissions);
-            try ret_file.setOwner(io, try id_table.get(io, inode.hdr.uid_idx), try id_table.get(io, inode.hdr.gid_idx));
-        }
-        if (!que.type_erased.closed and group.token.raw == null) que.close(io);
-    }
-}
-pub fn extractDir(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    fil: OffsetFile,
-    decomp: *const Decompressor,
-    frag: *LookupTable.CachedTable(FragEntry),
-    block_size: u32,
-    dir_start: u64,
-    inode_start: u64,
-    path: []const u8,
-    options: ExtractionOptions,
-    que: *Io.Queue(FileRet),
-) !void {
-    defer alloc.free(path);
-
-    const dirs = try self.readDirectory(alloc, io, fil, decomp, dir_start);
-    defer {
-        for (dirs) |d|
-            d.deinit(alloc);
-        alloc.free(dirs);
-    }
-
-    var group: Io.Group = .init;
-    defer group.cancel(io);
-
-    for (dirs) |d| {
-        var rdr = try fil.readerAt(io, d.block_start + inode_start, &[0]u8{});
-        var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
-        try meta.interface.discardAll(d.block_offset);
-
-        const inode = try read(alloc, &meta.interface, block_size);
-
-        const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", d.name });
-
-        switch (inode.hdr.inode_type) {
-            .dir, .ext_dir => group.async(io, extractDir, .{
-                self,
-                alloc,
-                io,
-                fil,
-                &decomp.interface,
-                &frag,
-                block_size,
-                dir_start,
-                new_path,
-                options,
-                &que,
-            }),
-            .file, .ext_file => group.async(io, extractRegFile, .{
-                self,
-                alloc,
-                io,
-                file,
-                &decomp.interface,
-                &frag,
-                block_size,
-                new_path,
-                options,
-                &que,
-            }),
-            .symlink, .ext_symlink => group.async(Io, extractSymlink, .{ self, alloc, io, new_path, options, &que }),
-            else => group.async(io, extractDevice, .{ self, alloc, io, new_path, options, &que }),
-        }
-    }
-
-    try group.await(io);
-
-    try que.putOne(io, .{ .file = try Io.Dir.cwd().openFile(io, path, .{}), .inode = self });
-}
-pub fn extractRegFile(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    fil: OffsetFile,
-    decomp: *const Decompressor,
-    frag: *LookupTable.CachedTable(FragEntry),
-    block_size: u32,
-    path: []const u8,
-    options: ExtractionOptions,
-    que: *Io.Queue(FileRet),
-) !void {
-    _ = options;
-    defer alloc.free(path);
-
-    const atom = try Io.Dir.cwd().createFileAtomic(io, path, .{});
-    defer atom.deinit(io);
-
-    var size: u64 = undefined;
-    var start: u64 = undefined;
-    var blocks: []file.BlockSize = undefined;
-    var frag_idx: u32 = undefined;
-    var frag_offset: u32 = undefined;
-    switch (self.data) {
-        .file => |f| {
-            size = f.size;
-            start = f.block_start;
-            blocks = f.block_sizes;
-            frag_idx = f.frag_idx;
-            frag_offset = f.frag_block_offset;
         },
-        .ext_file => |f| {
+        .symlink, .ext_symlink => try Io.Dir.cwd().symLink(io, self.symlinkTarget() catch unreachable, path, .{}),
-            size = f.size;
+        else => {
-            start = f.block_start;
-            blocks = f.block_sizes;
-            frag_idx = f.frag_idx;
-            frag_offset = f.frag_block_offset;
-        },
-        else => unreachable,
-    }
-
-    const ext: DataExtractor = .init(fil, decomp, block_size, size, start, blocks);
-    ext.addFrag(frag_offset, try frag.get(io, frag_idx));
-
-    var group: Io.Group = .init;
-    defer group.cancel(io);
-
-    ext.extractAsync(alloc, io, &group, atom.file);
-
-    try group.await(io);
-
-    try atom.link(io);
-
-    try que.putOne(io, .{ .file = atom.file, .inode = self });
-}
-pub fn extractSymlink(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    path: []const u8,
-    options: ExtractionOptions,
-    que: *Io.Queue(FileRet),
-) !void {
-    defer alloc.free(path);
-
-    _ = options;
-    _ = que;
-    // TODO: handle symlink options
-    const target = try self.symlinkTarget();
-
-    try Io.Dir.cwd().symLink(io, target, path, .{});
-
-    // TODO: On Linux you can't set permission & xattrs on symlinks (they inherit from their target), but on Mac you can.
-}
-pub fn extractDevice(
-    self: Inode,
-    alloc: std.mem.Allocator,
-    io: Io,
-    path: []const u8,
-    options: ExtractionOptions,
-    que: *Io.Queue(FileRet),
-) !void {
-    defer alloc.free(path);
-
-    var dev: u32 = 0;
             var mode: u32 = undefined;
+            var dev: u32 = 0;
+
+            const DT = std.posix.DT;
 
             switch (self.data) {
                 .char_dev => |d| {
                     dev = d.dev;
-            mode = std.posix.DT.CHR;
+                    mode = DT.CHR;
-        },
-        .block_dev => |d| {
-            dev = d.dev;
-            mode = std.posix.DT.BLK;
                 },
                 .ext_char_dev => |d| {
                     dev = d.dev;
-            mode = std.posix.DT.BLK;
+                    mode = DT.CHR;
+                },
+                .block_dev => |d| {
+                    dev = d.dev;
+                    mode = DT.BLK;
                 },
                 .ext_block_dev => |d| {
                     dev = d.dev;
-            mode = std.posix.DT.BLK;
+                    mode = DT.BLK;
                 },
-        .fifo, .ext_fifo => mode = std.posix.DT.FIFO,
+                .fifo, .ext_fifo => mode = DT.FIFO,
-        .socket, .ext_socket => mode = std.posix.DT.SOCK,
+                .socket, .ext_socket => mode = DT.SOCK,
                 else => unreachable,
             }
 
-    const sentinel_path = try std.mem.concatMaybeSentinel(alloc, u8, &[1][]const u8{path}, 0);
+            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{path}, 0);
-    defer alloc.free(sentinel_path);
             const res = std.os.linux.mknod(sentinel_path, mode, dev);
-    if (res != 0 and options.verbose)
+            alloc.free(sentinel_path);
-        options.verbose_writer.?.print("mknod failed with code: {}\n", .{res}) catch {};
+            if (res != 0)
-
+                return ExtractError.MknodFailed;
-    try que.putOne(io, .{
+        },
-        .file = try Io.Dir.cwd().openFile(io, path, .{}),
+    }
+    return .{
+        .path = path,
         .inode = self,
-    });
+        .origin = origin,
+    };
 }
-
+fn finishLoop(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, super: Archive.Superblock, options: ExtractionOptions, sel: *Io.Select(ExtractReturnUnion)) !void {
-fn applyMetadataLoop(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, super: Archive.Superblock, que: *Io.Queue(FileRet), options: ExtractionOptions) !void {
+    var id_table: CachedTable(u16) = .init(alloc, fil, decomp, super.id_start, super.id_count);
-    var id_table: LookupTable.CachedTable(u16) = .init(alloc, fil, decomp, super.id_start, super.id_count);
     defer id_table.deinit(io);
-    var xattr_table: XattrTable = try .init(alloc, io, fil, decomp, super.xattr_start);
-    defer xattr_table.deinit(io);
-    for (try que.getOne(io)) |ret| {
-        const inode: Inode = ret.inode;
-        defer inode.deinit(alloc);
-        const ret_file: Io.File = ret.file;
-        defer ret_file.close(io);
 
-        if (!options.ignore_xattr) {
+    var xattr_table: ?XattrTable = if (super.flags.xattr_never or options.ignore_xattr or !@hasField(std.os, "linux"))
-            if (inode.xattrIndex()) |idx| {
+        null
-                const xattrs = try xattr_table.get(io, idx);
+    else
-                for (xattrs) |x| {
+        try .init(alloc, fil, decomp, super.xattr_start);
-                    // TODO: Check error.
+    defer if (xattr_table != null) xattr_table.?.deinit(io);
-                    _ = std.os.linux.fsetxattr(ret_file.handle, x.key, x.value.ptr, x.value.len, 0);
+
+    var dir_queue: std.PriorityDequeue(PathRet, void, DirCompare) = .empty;
+    defer dir_queue.deinit(alloc);
+
+    while (true) {
+        if (sel.group.token.load(.unordered) == null) break;
+
+        const ret = try sel.await();
+        const path_ret = try ret.path_ret;
+
+        if (options.ignore_permissions and xattr_table == null) {
+            path_ret.deinit(alloc);
+            continue;
         }
+
+        if (path_ret.inode.hdr.inode_type == .dir or path_ret.inode.hdr.inode_type == .ext_dir) {
+            try dir_queue.push(alloc, path_ret);
+            continue;
         }
+        defer path_ret.deinit(alloc);
+
+        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
     }
+
+    while (sel.cancel()) |ret| {
+        const path_ret = try ret.path_ret;
+
+        if (options.ignore_permissions and xattr_table == null) {
+            path_ret.deinit(alloc);
+            continue;
+        }
+
+        if (path_ret.inode.hdr.inode_type == .dir or path_ret.inode.hdr.inode_type == .ext_dir) {
+            try dir_queue.push(alloc, path_ret);
+            continue;
+        }
+
+        defer path_ret.deinit(alloc);
+        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
+    }
+
+    var iter = dir_queue.iterator();
+    while (iter.next()) |path_ret| {
+        defer path_ret.deinit(alloc);
+        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
+    }
+}
+/// Extracts the given inode to the given path. If the inode not a directory, the given path must not exist.
+/// If the inode is a directory the path must not exist or be a directory.
+fn extractSinglethreaded(
+    self: Inode,
+    alloc: std.mem.Allocator,
+    io: Io,
+    fil: OffsetFile,
+    super: Archive.Superblock,
+    path: []const u8,
+    options: ExtractionOptions,
+    decomp: *Decompressor,
+    frag: *FragManager,
+) !void {
+    var id_table: CachedTable(u16) = .init(alloc, fil, decomp, super.id_start, super.id_count);
+    defer id_table.deinit(io);
+
+    var xattr_table: ?XattrTable = if (super.flags.xattr_never or options.ignore_xattr or !@hasField(std.os, "linux"))
+        null
+    else
+        try .init(alloc, fil, decomp, super.xattr_start);
+    defer if (xattr_table != null) xattr_table.?.deinit(io);
+
+    return self.extractReal(
+        alloc,
+        io,
+        fil,
+        super,
+        decomp,
+        frag,
+        &id_table,
+        if (xattr_table == null) null else &xattr_table.?,
+        path,
+        options,
+    );
+}
+fn extractReal(
+    self: Inode,
+    alloc: std.mem.Allocator,
+    io: Io,
+    fil: OffsetFile,
+    super: Archive.Superblock,
+    decomp: *Decompressor,
+    frag_mgr: *FragManager,
+    id_table: *CachedTable(u16),
+    xattr_table: ?*XattrTable,
+    path: []const u8,
+    options: ExtractionOptions,
+) !void {
+    switch (self.hdr.inode_type) {
+        .dir, .ext_dir => {
+            try Io.Dir.cwd().createDir(io, path, @enumFromInt(0o777));
+
+            const entries = self.readDirectory(alloc, fil, decomp, super.dir_start) catch |err| switch (err) {
+                Error.NotDirectory, Error.NotExtended, Error.NotRegularFile, Error.NotSymlink => unreachable,
+                else => |e| return e,
+            };
+            defer {
+                for (entries) |e|
+                    e.deinit(alloc);
+                alloc.free(entries);
+            }
+
+            for (entries) |e| {
+                const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", e.name });
+                defer alloc.free(new_path);
+
+                var rdr = fil.readerAt(super.inode_start + e.block_start);
+                var meta: MetadataReader = .init(alloc, &rdr, decomp);
+                try meta.interface.discardAll(e.block_offset);
+
+                const new_inode = try read(alloc, &meta.interface, super.block_size);
+                defer new_inode.deinit(alloc);
+
+                try new_inode.extractReal(alloc, io, fil, super, decomp, frag_mgr, id_table, xattr_table, new_path, options);
+            }
+        },
+        .file, .ext_file => {
+            var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{ .make_path = true });
+            defer atomic.deinit(io);
+
+            var rdr: DataReader = switch (self.data) {
+                .file => |f| blk: {
+                    var ext: DataReader = try .init(alloc, io, fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
+                    if (f.frag_idx != 0xFFFFFFFF)
+                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
+                    break :blk ext;
+                },
+                .ext_file => |f| blk: {
+                    var ext: DataReader = try .init(alloc, io, fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
+                    if (f.frag_idx != 0xFFFFFFFF)
+                        ext.addFrag(f.frag_block_offset, try frag_mgr.get(io, f.frag_idx));
+                    break :blk ext;
+                },
+                else => unreachable,
+            };
+            defer rdr.deinit();
+
+            var buf: [512 * 1024]u8 = undefined;
+            var wrt = atomic.file.writer(io, &buf);
+
+            _ = try rdr.interface.streamRemaining(&wrt.interface);
+
+            try wrt.flush();
+
+            try atomic.link(io);
+        },
+        .symlink, .ext_symlink => try Io.Dir.cwd().symLink(io, self.symlinkTarget() catch unreachable, path, .{}),
+        else => {
+            var mode: u32 = undefined;
+            var dev: u32 = 0;
+
+            const DT = std.posix.DT;
+
+            switch (self.data) {
+                .char_dev => |d| {
+                    dev = d.dev;
+                    mode = DT.CHR;
+                },
+                .ext_char_dev => |d| {
+                    dev = d.dev;
+                    mode = DT.CHR;
+                },
+                .block_dev => |d| {
+                    dev = d.dev;
+                    mode = DT.BLK;
+                },
+                .ext_block_dev => |d| {
+                    dev = d.dev;
+                    mode = DT.BLK;
+                },
+                .fifo, .ext_fifo => mode = DT.FIFO,
+                .socket, .ext_socket => mode = DT.SOCK,
+                else => unreachable,
+            }
+
+            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{path}, 0);
+            const res = std.os.linux.mknod(sentinel_path, mode, dev);
+            alloc.free(sentinel_path);
+            if (res != 0)
+                return ExtractError.MknodFailed;
+        },
+    }
+    if (options.ignore_permissions and options.ignore_xattr) return;
+
+    var f = try Io.Dir.cwd().openFile(io, path, .{});
+    defer f.close(io);
+
     if (!options.ignore_permissions) {
-            try ret_file.setPermissions(io, inode.hdr.permissions);
+        try f.setPermissions(io, @enumFromInt(self.hdr.permissions));
-            try ret_file.setOwner(io, try id_table.get(io, inode.hdr.uid_idx), try id_table.get(io, inode.hdr.gid_idx));
+        try f.setOwner(io, try id_table.get(io, self.hdr.uid_idx), try id_table.get(io, self.hdr.gid_idx));
+    }
+    if (xattr_table != null) {
+        const idx = self.xattrIndex() catch return;
+
+        const xattrs = try xattr_table.?.get(alloc, io, idx);
+        defer {
+            for (xattrs) |x|
+                x.deinit(alloc);
+            alloc.free(xattrs);
+        }
+
+        const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{path}, 0);
+        defer alloc.free(sentinel_path);
+        for (xattrs) |x| {
+            const xattr_ret = std.os.linux.fsetxattr(f.handle, x.key, x.value.ptr, x.value.len, 0);
+            if (xattr_ret != 0)
+                return ExtractError.CannotSetXattr;
         }
     }
 }

src/inode_data/dir.zig

@@ -21,7 +21,7 @@ pub const ExtDir = extern struct {
     parent_num: u32,
     idx_count: u16,
     block_offset: u16,
-    xattr_id: u32,
+    xattr_idx: u32,
     // index: []DirIndex
 
     pub fn read(rdr: *Reader) !ExtDir {

src/lookup_table.zig

@@ -5,17 +5,16 @@ const Decompressor = @import("util/decompressor.zig");
 const MetadataReader = @import("util/metadata.zig");
 const OffsetFile = @import("util/offset_file.zig");
 
-pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, io: Io, decomp: *Decompressor, file: OffsetFile, table_start: u64, idx: u16) !T {
+pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, decomp: *Decompressor, file: OffsetFile, table_start: u64, idx: u32) !T {
     const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
 
     const block = idx / T_PER_BLOCK;
     const block_offset = idx % T_PER_BLOCK;
 
-    var rdr = try file.readerAt(io, table_start + (8 * block), &[0]u8{});
+    const offset_pos = table_start + (8 * block);
-    var offset: u64 = undefined;
+    const offset: u64 = std.mem.readInt(u64, @ptrCast(file.map.memory[offset_pos .. offset_pos + 8]), .little);
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&offset), .little);
 
-    rdr = try file.readerAt(io, offset, &[0]u8{});
+    var rdr = file.readerAt(offset);
     var meta: MetadataReader = .init(alloc, &rdr, decomp);
 
     try meta.interface.discardAll(@sizeOf(T) * block_offset);
@@ -24,6 +23,8 @@ pub fn lookupValue(comptime T: anytype, alloc: std.mem.Allocator, io: Io, decomp
     return out;
 }
 
+pub const Error = Io.Cancelable || Io.File.Reader.SeekError || Io.Reader.ReadAllocError;
+
 pub fn CachedTable(comptime T: anytype) type {
     return struct {
         const T_PER_BLOCK: u16 = 8192 / @sizeOf(T);
@@ -32,16 +33,16 @@ pub fn CachedTable(comptime T: anytype) type {
 
         alloc: std.mem.Allocator,
         fil: OffsetFile,
-        decomp: *const Decompressor,
+        decomp: *Decompressor,
 
         table_start: u64,
         total_num: u32,
 
         table: std.AutoHashMap(u32, []T),
 
-        mut: Io.Mutex = .init,
+        mut: Io.RwLock = .init,
 
-        pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, offset: u64, total_num: u32) Table {
+        pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *Decompressor, offset: u64, total_num: u32) Table {
             return .{
                 .alloc = alloc,
                 .fil = fil,
@@ -55,14 +56,48 @@ pub fn CachedTable(comptime T: anytype) type {
         }
         pub fn deinit(self: *Table, io: Io) void {
             self.mut.lockUncancelable(io);
+            var iter = self.table.valueIterator();
+            while (iter.next()) |val|
+                self.alloc.free(val.*);
             self.table.deinit();
         }
 
-        pub fn get(self: *Table, io: Io, idx: u32) !T {
+        pub fn fill(self: *Table, io: Io) Error!void {
+            try self.mut.lock(io);
+            defer self.mut.unlock(io);
+
+            var num_blocks = self.total_num / T_PER_BLOCK;
+            if (self.total_num % T_PER_BLOCK > 0)
+                num_blocks += 1;
+
+            for (0..num_blocks) |block| {
+                const offset_pos = self.table_start + (8 * block);
+                const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
+
+                const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
+                    @truncate(self.total_num % T_PER_BLOCK)
+                else
+                    T_PER_BLOCK;
+
+                var rdr = self.fil.readerAt(offset);
+                var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
+
+                const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
+                try self.table.put(@truncate(block), slice);
+            }
+        }
+
+        pub fn get(self: *Table, io: Io, idx: u32) Error!T {
             const block = idx / T_PER_BLOCK;
             const block_offset = idx % T_PER_BLOCK;
+
+            {
+                try self.mut.lockShared(io);
+                defer self.mut.unlockShared(io);
+
                 if (self.table.contains(block))
                     return self.table.get(block).?[block_offset];
+            }
 
             try self.mut.lock(io);
             defer self.mut.unlock(io);
@@ -70,19 +105,21 @@ pub fn CachedTable(comptime T: anytype) type {
             if (self.table.contains(block))
                 return self.table.get(block).?[block_offset];
 
-            var rdr = try self.fil.readerAt(io, self.table_start + (8 * block), &[0]u8{});
+            const offset_pos = self.table_start + (8 * block);
-            var offset: u64 = undefined;
+            const offset: u64 = std.mem.readInt(u64, @ptrCast(self.fil.map.memory[offset_pos .. offset_pos + 8]), .little);
-            try rdr.interface.readSliceEndian(u64, @ptrCast(&offset), .little);
 
             const len: u16 = if (self.total_num % T_PER_BLOCK != 0 and block == (self.total_num - 1) / T_PER_BLOCK)
-                self.total_num % T_PER_BLOCK
+                @truncate(self.total_num % T_PER_BLOCK)
             else
                 T_PER_BLOCK;
 
-            rdr = try self.fil.readerAt(io, offset, &[0]u8{});
+            var rdr = self.fil.readerAt(offset);
             var meta: MetadataReader = .init(self.alloc, &rdr, self.decomp);
 
-            try self.table.put(block, try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little));
+            const slice = try meta.interface.readSliceEndianAlloc(self.alloc, T, len, .little);
+            try self.table.put(@truncate(block), slice);
+
+            return slice[block_offset];
         }
     };
 }

src/options.zig

@@ -5,8 +5,10 @@ const Writer = std.Io.Writer;
 
 const ExtractionOptions = @This();
 
-/// The number of threads used for extraction. 0 implies single threaded.
+/// Extract single-threaded only.
-threads: usize = 1,
+/// Though not necessary if using Threaded.single_threaded,
+/// setting single_threaded is more efficient.
+single_threaded: bool = false,
 /// Don't set the file's owner & permissions after extraction
 ignore_permissions: bool = false,
 /// Don't set xattr values. Currently xattrs are never set anyway.
@@ -18,16 +20,12 @@ verbose: bool = false,
 /// Where to print verbose log.
 verbose_writer: ?*Writer = null,
 
-pub const SingleThreadedDefault: ExtractionOptions = .{};
+pub const default: ExtractionOptions = .{};
-pub fn Default() !ExtractionOptions {
+pub const default_single_threaded: ExtractionOptions = .{ .single_threaded = true };
-    return .{
+
-        .threads = try std.Thread.getCpuCount(),
-    };
-}
 pub fn VerboseDefault(wrt: *Writer) !ExtractionOptions {
     return .{
         .verbose = true,
         .verbose_writer = wrt,
-        .threads = try std.Thread.getCpuCount(),
     };
 }

src/root.zig

@@ -1,2 +1,6 @@
 pub const Archive = @import("archive.zig");
 pub const ExtractionOptions = @import("options.zig");
+
+test {
+    @import("std").testing.refAllDecls(@This());
+}

src/test.zig

@@ -1,83 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const io = std.testing.io;
-const alloc = std.testing.allocator;
-const stuff = @import("builtin");
-
-const Archive = @import("archive.zig");
-const Superblock = Archive.Superblock;
-
-const TestArchive = "testing/LinuxPATest.sfs";
-
-test "Basics" {
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    try std.testing.expectEqualDeep(sfs.super, LinuxPATestCorrectSuperblock);
-    const root_file = try sfs.root(alloc, io);
-    defer root_file.deinit();
-}
-
-const TestFile = "Start.exe";
-const TestFileExtractLocation = "testing/Start.exe";
-
-test "ExtractSingleFile" {
-    Io.Dir.cwd().deleteFile(io, TestFileExtractLocation) catch {};
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    var test_fil = try sfs.open(alloc, io, TestFile);
-    defer test_fil.deinit();
-    try test_fil.extract(alloc, io, TestFileExtractLocation, try .Default());
-    //TODO: validate extracted file.
-}
-
-const TestFullExtractLocation = "testing/TestExtract";
-
-test "ExtractCompleteArchive" {
-    Io.Dir.cwd().deleteTree(io, TestFullExtractLocation) catch {};
-    var fil = try Io.Dir.cwd().openFile(io, TestArchive, .{});
-    defer fil.close(io);
-    var sfs: Archive = try .init(io, fil, 0);
-    try sfs.extract(alloc, io, TestFullExtractLocation, try .Default());
-}
-
-const LinuxPATestCorrectSuperblock: Superblock = .{
-    .magic = std.mem.readInt(u32, "hsqs", .little),
-    .inode_count = 2974,
-    .mod_time = 1632696724,
-    .block_size = 131072,
-    .frag_count = 264,
-    .compression = .zstd,
-    .block_log = 17,
-    .flags = .{
-        .inode_uncompressed = false,
-        .data_uncompressed = false,
-        .check = false,
-        .frag_uncompressed = false,
-        .fragment_never = false,
-        .fragment_always = false,
-        .duplicates = true,
-        .exportable = true,
-        .xattr_uncompressed = false,
-        .xattr_never = false,
-        .compression_options = false,
-        .ids_uncompressed = false,
-        ._ = 0,
-    },
-    .id_count = 1,
-    .ver_maj = 4,
-    .ver_min = 0,
-    .root_ref = .{
-        .block_offset = 1363,
-        .block_start = 29237,
-        ._ = 0,
-    },
-    .size = 106841744,
-    .id_start = 106841632,
-    .xattr_start = 106841720,
-    .inode_start = 106778274,
-    .dir_start = 106807998,
-    .frag_start = 106837747,
-    .export_start = 106841602,
-};

src/util/data_extractor.zig

@@ -7,13 +7,15 @@ const FragEntry = @import("../frag.zig").FragEntry;
 const BlockSize = @import("../inode_data/file.zig").BlockSize;
 const Decompressor = @import("decompressor.zig");
 const OffsetFile = @import("offset_file.zig");
-const SharedCache = @import("shared_cache.zig");
+
+// const SharedCache = @import("shared_cache.zig");
+
+pub const Error = Decompressor.Error || Io.File.MemoryMap.CreateError || Io.File.WritePositionalError;
 
 const DataExtractor = @This();
 
 fil: OffsetFile,
-// cache: *SharedCache,
+decomp: *Decompressor,
-decomp: *const Decompressor,
 block_size: u32,
 
 file_size: u64,
@@ -21,12 +23,13 @@ start: u64,
 blocks: []BlockSize,
 
 frag_offset: u32 = 0,
-frag_entry: ?FragEntry = null,
+frag_block: ?[]u8 = null,
 
-pub fn init(fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) DataExtractor {
+err: ?Error = null,
+
+pub fn init(fil: OffsetFile, decomp: *Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) DataExtractor {
     return .{
         .fil = fil,
-        // .cache = cache,
         .decomp = decomp,
         .block_size = block_size,
 
@@ -35,29 +38,52 @@ pub fn init(fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_
         .blocks = blocks,
     };
 }
-pub fn addFrag(self: *DataExtractor, frag_offset: u32, entry: FragEntry) void {
+pub fn addFrag(self: *DataExtractor, frag_offset: u32, block: []u8) void {
     self.frag_offset = frag_offset;
-    self.frag_entry = entry;
+    self.frag_block = block;
 }
 
 fn numBlocks(self: DataExtractor) usize {
     var num = self.blocks.len;
-    if (self.frag_entry != null) num += 1;
+    if (self.frag_block != null) num += 1;
     return num;
 }
 
 /// Starts extracting the data using the given group to spawn async tasks.
-pub fn extractAsync(self: DataExtractor, alloc: std.mem.Allocator, io: Io, group: *Io.Group, fil: Io.File) void {
+pub fn extractConcurrent(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File) (Error || Io.ConcurrentError)!void {
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+    var err: ?Error = null;
+
     var read_offset: u64 = self.start;
     for (0..self.blocks.len) |idx| {
-        group.async(io, blockThread, .{ self, alloc, io, fil, read_offset, idx });
+        try group.concurrent(io, blockThread, .{ self, alloc, io, fil, read_offset, idx, &err });
         read_offset += self.blocks[idx].size;
     }
-    if (self.frag_entry != null)
+    if (self.frag_block != null)
-        group.async(io, fragThread, .{ self, alloc, io, fil });
+        try group.concurrent(io, fragThread, .{ self, io, fil, &err });
+
+    group.await(io) catch |cancel| return err orelse cancel;
 }
 
-fn blockThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File, read_offset: u64, idx: u32) !void {
+/// Starts extracting the data using the given group to spawn async tasks.
+pub fn extractAsync(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File) Error!void {
+    var group: Io.Group = .init;
+    defer group.cancel(io);
+    var err: ?Error = null;
+
+    var read_offset: u64 = self.start;
+    for (0..self.blocks.len) |idx| {
+        group.async(io, blockThread, .{ self, alloc, io, fil, read_offset, idx, &err });
+        read_offset += self.blocks[idx].size;
+    }
+    if (self.frag_block != null)
+        group.async(io, fragThread, .{ self, io, fil, &err });
+
+    group.await(io) catch |cancel| return err orelse cancel;
+}
+
+fn blockThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File, read_offset: u64, idx: usize, ret_err: *?Error) Io.Cancelable!void {
     const block = self.blocks[idx];
 
     const cur_block_size = if (idx == self.numBlocks() - 1)
@@ -65,55 +91,72 @@ fn blockThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.Fi
     else
         self.block_size;
 
+    const write_offset = self.block_size * idx;
+
     var wrt = fil.writer(io, &[0]u8{});
-    try wrt.seekTo(self.block_size * idx);
+    wrt.seekTo(write_offset) catch |err| {
-    defer wrt.flush() catch {};
+        ret_err.* = err;
+        if (err == error.Canceled) io.recancel();
+        return Io.Cancelable.Canceled;
+    };
 
     if (block.size == 0) {
-        try wrt.interface.splatByteAll(0, cur_block_size);
+        wrt.interface.splatByteAll(0, cur_block_size) catch |err| {
-        return;
+            ret_err.* = err;
-    }
+            if (err == error.Canceled) io.recancel();
-
+            return Io.Cancelable.Canceled;
-    var rdr = try self.fil.readerAt(io, read_offset, &[0]u8{});
+        };
+    } else {
         if (block.uncompressed) {
-        try rdr.interface.streamExact(&wrt, cur_block_size);
+            wrt.interface.writeAll(self.fil.map.memory[read_offset..][0..cur_block_size]) catch |err| {
-        return;
+                ret_err.* = err;
+                if (err == error.Canceled) io.recancel();
+                return Io.Cancelable.Canceled;
+            };
         } else {
             @branchHint(.likely);
-        var cache = try self.cache.getCache(io);
-        defer self.cache.returnCache(cache);
 
-        var tmp = try self.cache.getCache(io);
+            var tmp: [1024 * 1024]u8 = undefined;
-        defer self.cache.returnCache(tmp);
 
-        try rdr.interface.readSliceAll(cache.cache[0..block.size]);
+            _ = self.decomp.Decompress(alloc, self.fil.map.memory[read_offset..][0..block.size], tmp[0..cur_block_size]) catch |err| {
-        _ = try self.decomp.Decompress(alloc, cache.cache[0..block.size], tmp.cache[0..cur_block_size]);
+                ret_err.* = err;
-        try wrt.interface.writeAll(tmp.cache[0..cur_block_size]);
+                return Io.Cancelable.Canceled;
+            };
+
+            wrt.interface.writeAll(tmp[0..cur_block_size]) catch |err| {
+                ret_err.* = err;
+                if (err == error.Canceled) io.recancel();
+                return Io.Cancelable.Canceled;
+            };
         }
+    }
+    wrt.flush() catch |err| {
+        ret_err.* = err;
+        if (err == error.Canceled) io.recancel();
+        return Io.Cancelable.Canceled;
+    };
 }
-fn fragThread(self: DataExtractor, alloc: std.mem.Allocator, io: Io, fil: Io.File) !void {
+fn fragThread(self: DataExtractor, io: Io, fil: Io.File, ret_err: *?Error) Io.Cancelable!void {
-    const frag = self.frag_entry.?;
     const cur_block_size = self.file_size % self.block_size;
 
+    const write_offset = self.blocks.len * self.block_size;
+
     var wrt = fil.writer(io, &[0]u8{});
-    try wrt.seekTo(self.blocks.len * self.block_size);
+    wrt.seekTo(write_offset) catch |err| {
-    defer wrt.flush() catch {};
+        ret_err.* = err;
+        if (err == error.Canceled) io.recancel();
+        return Io.Cancelable.Canceled;
+    };
 
-    var rdr = try self.fil.readerAt(io, frag.start, &[0]u8{});
+    wrt.interface.writeAll(self.frag_block.?[self.frag_offset..][0..cur_block_size]) catch |err| {
-    if (frag.size.uncompressed) {
+        ret_err.* = err;
-        try rdr.interface.discardAll(self.frag_offset);
+        if (err == error.Canceled) io.recancel();
-        try rdr.interface.streamExact(&wrt, cur_block_size);
+        return Io.Cancelable.Canceled;
-        return;
+    };
-    } else {
-        @branchHint(.likely);
-        var cache = try self.cache.getCache(io);
-        defer self.cache.returnCache(cache);
 
-        var tmp = try self.cache.getCache(io);
+    wrt.flush() catch |err| {
-        defer self.cache.returnCache(tmp);
+        ret_err.* = err;
-
+        if (err == error.Canceled) io.recancel();
-        try rdr.interface.readSliceAll(cache.cache[0..frag.size.size]);
+        return Io.Cancelable.Canceled;
-        _ = try self.decomp.Decompress(alloc, cache.cache[0..frag.size.size], tmp.cache[0..self.block_size]);
+    };
-        try wrt.interface.writeAll(tmp.cache[0..cur_block_size]);
-    }
 }

src/util/data_reader.zig

@@ -6,11 +6,11 @@ const Reader = Io.Reader;
 const Writer = Io.Writer;
 const Limit = Io.Limit;
 
-const FragEntry = @import("../frag.zig").FragEntry;
 const BlockSize = @import("../inode_data/file.zig").BlockSize;
 const Decompressor = @import("decompressor.zig");
 const OffsetFile = @import("offset_file.zig");
-const SharedCache = @import("shared_cache.zig");
+
+// const SharedCache = @import("shared_cache.zig");
 
 const DataReader = @This();
 
@@ -18,8 +18,7 @@ alloc: std.mem.Allocator,
 
 fil: OffsetFile,
 io: Io,
-// cache: *SharedCache,
+decomp: *Decompressor,
-decomp: *const Decompressor,
 block_size: u32,
 
 file_size: u64,
@@ -27,14 +26,14 @@ cur_offset: u64,
 blocks: []BlockSize,
 
 frag_offset: u32 = 0,
-frag_entry: ?FragEntry = null,
+frag_block: ?[]u8 = null,
 
 block_idx: usize = 0,
 sparse_block: bool = false,
 
 interface: Io.Reader,
 
-pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) !DataReader {
+pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) !DataReader {
     return .{
         .alloc = alloc,
 
@@ -62,43 +61,31 @@ pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const De
 pub fn deinit(self: *DataReader) void {
     self.alloc.free(self.interface.buffer);
 }
-pub fn addFrag(self: *DataReader, frag_offset: u32, entry: FragEntry) void {
+pub fn addFrag(self: *DataReader, frag_offset: u32, block: []u8) void {
     self.frag_offset = frag_offset;
-    self.frag_entry = entry;
+    self.frag_block = block;
 }
 
 fn numBlocks(self: DataReader) usize {
     var num = self.blocks.len;
-    if (self.frag_entry != null) num += 1;
+    if (self.frag_block != null) num += 1;
     return num;
 }
 fn advanceBuffer(self: *DataReader) !void {
-    if (self.block_idx >= self.numBlocks()) {
+    if (self.block_idx >= self.numBlocks())
         return Reader.Error.EndOfStream;
-    }
+
+    errdefer self.interface.end = 0;
     defer self.block_idx += 1;
 
     self.interface.end = if (self.block_idx == self.numBlocks() - 1)
-        self.size % self.block_size
+        self.file_size % self.block_size
     else
         self.block_size;
 
     // Fragment
     if (self.block_idx == self.blocks.len) {
-        const entry = self.frag_entry.?;
+        @memcpy(self.interface.buffer[0..self.interface.end], self.frag_block.?[self.frag_offset .. self.frag_offset + self.interface.end]);
-        if (entry.size.uncompressed) {
-            var rdr = try self.fil.readerAt(self.io, entry.start + self.frag_offset, &[0]u8{});
-            try rdr.interface.readSliceAll(self.interface.buffer[0..self.interface.end]);
-        } else {
-            @branchHint(.likely);
-            const tmp = try self.cache.getCache(self.io);
-            defer self.cache.returnCache(tmp);
-
-            var rdr = try self.fil.readerAt(self.io, entry.start, &[0]u8{});
-            try rdr.interface.readSliceAll(tmp.cache[0..entry.size.size]);
-            _ = try self.decomp.Decompress(self.alloc, tmp.cache[0..entry.size.size], self.interface.buffer[0..self.block_size]);
-            @memmove(self.interface.buffer[0..self.interface.end], self.interface.buffer[self.frag_offset .. self.frag_offset + self.interface.end]);
-        }
         self.interface.seek = 0;
         return;
     }
@@ -113,17 +100,13 @@ fn advanceBuffer(self: *DataReader) !void {
         self.sparse_block = false;
     }
     if (block.uncompressed) {
-        try self.fil.readAt(self.io, self.cur_offset, self.interface.buffer[0..self.interface.end]);
+        @memcpy(self.interface.buffer[0..self.interface.end], self.fil.map.memory[self.cur_offset .. self.cur_offset + self.interface.end]);
         self.cur_offset += self.interface.end;
     } else {
         @branchHint(.likely);
-        const tmp = try self.cache.getCache(self.io);
-        defer self.cache.returnCache(tmp);
 
-        var rdr = try self.fil.readerAt(self.io, self.cur_offset, &[0]u8{});
+        _ = try self.decomp.Decompress(self.alloc, self.fil.map.memory[self.cur_offset .. self.cur_offset + block.size], self.interface.buffer[0..self.interface.end]);
-        try rdr.interface.readSliceAll(tmp.cache[0..block.size]);
         self.cur_offset += block.size;
-        _ = try self.decomp.Decompress(self.alloc, tmp.cache[0..block.size], self.interface.buffer[0..self.interface.end]);
     }
     self.interface.seek = 0;
 }

src/util/decompressor.zig

@@ -8,8 +8,8 @@ pub const Error = std.Io.Reader.StreamError || std.mem.Allocator.Error;
 
 /// The actual decompression function.
 /// If the given decompressor is null, then the decompression should be done "stateless" without lasting allocations.
-decomp_fn: *const fn (?*const Decompressor, std.mem.Allocator, in: []u8, out: []u8) Error!usize,
+decomp_fn: *const fn (?*Decompressor, std.mem.Allocator, in: []u8, out: []u8) Error!usize,
 
-pub fn Decompress(self: *const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+pub fn Decompress(self: *Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
     return self.decomp_fn(self, alloc, in, out);
 }

src/util/metadata.zig

@@ -15,7 +15,7 @@ const This = @This();
 
 alloc: std.mem.Allocator,
 rdr: *Reader,
-decomp: *const Decompressor,
+decomp: *Decompressor,
 
 cur_block_start: u32 = 0,
 next_start_start: u32 = 0,
@@ -34,7 +34,7 @@ interface: Reader = .{
     },
 },
 
-pub fn init(alloc: std.mem.Allocator, rdr: *Reader, decomp: *const Decompressor) This {
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, decomp: *Decompressor) This {
     return .{
         .alloc = alloc,
         .rdr = rdr,

src/util/misc.zig

@@ -16,9 +16,9 @@ pub fn pathIsSelf(path: []const u8) bool {
     return path[0] == '.';
 }
 /// Creates an Inode from an Inode.Ref.
-pub fn inodeFromRef(alloc: std.mem.Allocator, io: Io, file: OffsetFile, decomp: *const Decompressor, inode_start: u64, block_size: u32, ref: Inode.Ref) !Inode {
+pub fn inodeFromRef(alloc: std.mem.Allocator, file: OffsetFile, decomp: *Decompressor, inode_start: u64, block_size: u32, ref: Inode.Ref) !Inode {
-    var rdr = try file.readerAt(io, inode_start + ref.block_start, &[0]u8{});
+    var rdr = file.readerAt(inode_start + ref.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
+    var meta: MetadataReader = .init(alloc, &rdr, decomp);
     try meta.interface.discardAll(ref.block_offset);
 
     return .read(alloc, &meta.interface, block_size);

src/util/offset_file.zig

@@ -3,27 +3,25 @@
 const std = @import("std");
 const Io = std.Io;
 const File = Io.File;
-const Reader = File.Reader;
+const Reader = Io.Reader;
 
 const OffsetFile = @This();
 
-fil: File,
+map: Io.File.MemoryMap,
-offset: u64,
 
-pub fn init(fil: File, init_offset: u64) OffsetFile {
+pub fn init(io: Io, fil: File, archive_size: u64, init_offset: u64) !OffsetFile {
-    return .{ .fil = fil, .offset = init_offset };
+    return .{
+        .map = try fil.createMemoryMap(io, .{
+            .protection = .{ .read = true, .write = false, .execute = false },
+            .len = archive_size,
+            .offset = init_offset,
+        }),
+    };
+}
+pub fn deinit(self: *OffsetFile, io: Io) void {
+    self.map.destroy(io);
 }
 
-pub fn readerAt(self: OffsetFile, io: Io, offset: u64, buffer: []u8) !Reader {
+pub fn readerAt(self: OffsetFile, offset: u64) Reader {
-    var rdr = self.fil.reader(io, buffer);
+    return .fixed(self.map.memory[offset..]);
-    try rdr.seekTo(self.offset + offset);
-    return rdr;
-}
-pub fn readAt(self: OffsetFile, io: Io, offset: u64, buf: []u8) !void {
-    _ = try self.fil.readPositionalAll(io, buf, self.offset + offset);
-}
-pub fn readValueAt(self: OffsetFile, comptime T: anytype, io: Io, offset: u64) !void {
-    //TODO: check for endianess and decode accordingly.
-    var new: T = undefined;
-    _ = try self.fil.readPositionalAll(io, @ptrCast(&new), self.offset + offset);
 }

src/util/shared_cache.zig

@@ -1,52 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-const Node = std.SinglyLinkedList.Node;
-
-const SharedCache = @This();
-
-pub const CACHE_SIZE = 1024 * 1024;
-
-pub const BufferNode = struct {
-    node: Node,
-    cache: [CACHE_SIZE]u8,
-};
-
-alloc: std.mem.Allocator,
-
-caches: std.ArrayList(BufferNode),
-cache_queue: std.SinglyLinkedList,
-queue_mut: Io.Mutex,
-
-pub fn init(alloc: std.mem.Allocator, init_cache_size: u32) !SharedCache {
-    const caches: std.ArrayList(BufferNode) = try .initCapacity(alloc, init_cache_size);
-    var queue: std.SinglyLinkedList = .{};
-    for (caches.items) |item|
-        queue.prepend(&item.node);
-    return .{
-        .alloc = alloc,
-
-        .caches = caches,
-        .cache_queue = queue,
-    };
-}
-pub fn deinit(self: *SharedCache) void {
-    self.caches.deinit(self.alloc);
-}
-
-pub fn getCache(self: *SharedCache, io: Io) !*BufferNode {
-    self.queue_mut.lock(io);
-    const nxt = self.cache_queue.popFirst();
-    self.queue_mut.unlock(io);
-    if (nxt == null) {
-        const new = try self.caches.addOne(self.alloc);
-        new.* = .{
-            .node = .{},
-            .cache = undefined,
-        };
-        return new;
-    }
-    return @fieldParentPtr("node", nxt.?);
-}
-pub fn returnCache(self: *SharedCache, buf: *BufferNode) void {
-    self.cache_queue.prepend(buf);
-}

src/xattr_table.zig

@@ -12,21 +12,17 @@ const XattrCachedTable = @This();
 alloc: std.mem.Allocator,
 
 fil: OffsetFile,
-decomp: *const Decompressor,
+decomp: *Decompressor,
 
 kv_start: u64,
 
 table: LookupTable.CachedTable(TableValue),
 value_cache: std.AutoHashMap(InodeRef, []const u8),
-value_mut: Io.Mutex,
+value_mut: Io.RwLock = .init,
 
-pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, xattr_start: u64) !XattrCachedTable {
+pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *Decompressor, xattr_start: u64) !XattrCachedTable {
-    var rdr = try fil.readerAt(io, xattr_start, &[0]u8{});
+    const start: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[xattr_start .. xattr_start + 8]), .little);
-
+    const num: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[xattr_start + 8 .. xattr_start + 16]), .little);
-    var start: u64 = undefined;
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&start), .little);
-    var num: u32 = undefined;
-    try rdr.interface.readSliceEndian(u32, @ptrCast(&num), .little);
 
     return .{
         .alloc = alloc,
@@ -36,11 +32,12 @@ pub fn init(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const De
 
         .kv_start = start,
 
-        .table = .init(alloc, fil, xattr_start + 16, num),
+        .table = .init(alloc, fil, decomp, xattr_start + 16, num),
         .value_cache = .init(alloc),
     };
 }
 pub fn deinit(self: *XattrCachedTable, io: Io) void {
+    self.value_mut.lockUncancelable(io);
     self.table.deinit(io);
     self.value_cache.deinit();
 }
@@ -48,45 +45,47 @@ pub fn deinit(self: *XattrCachedTable, io: Io) void {
 pub fn get(self: *XattrCachedTable, alloc: std.mem.Allocator, io: Io, idx: u32) ![]XattrSemiOwned {
     const lookup = try self.table.get(io, idx);
 
-    var rdr = try self.fil.readerAt(io, self.kv_start + lookup.ref.block_start, &[0]u8{});
+    var rdr = self.fil.readerAt(self.kv_start + lookup.ref.block_start);
-    var meta: MetadataReader = .init(alloc, &rdr.interface, self.decomp);
+    var meta: MetadataReader = .init(alloc, &rdr, self.decomp);
     try meta.interface.discardAll(lookup.ref.block_offset);
 
     const out = try alloc.alloc(XattrSemiOwned, lookup.count);
     errdefer alloc.free(out);
 
     for (0..lookup.count) |i| {
-        const key_entry: KeyEntry = undefined;
+        var key_entry: KeyEntry = undefined;
         try meta.interface.readSliceEndian(KeyEntry, @ptrCast(&key_entry), .little);
 
-        const key = switch (key_entry.type.namespace) {
+        const key: [:0]u8 = switch (key_entry.type.namespace) {
             .user => blk: {
                 const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 5);
                 errdefer alloc.free(tmp);
                 try meta.interface.readSliceEndian(u8, tmp[5 .. tmp.len - 1], .little);
-                @memset(tmp[0..5], "user.");
+                @memcpy(tmp[0..5], "user.");
-                break :blk tmp;
+                tmp[tmp.len - 1] = 0;
+                break :blk @ptrCast(tmp);
             },
             .trusted => blk: {
                 const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 8);
                 errdefer alloc.free(tmp);
                 try meta.interface.readSliceEndian(u8, tmp[8 .. tmp.len - 1], .little);
-                @memset(tmp[0..8], "trusted.");
+                @memcpy(tmp[0..8], "trusted.");
-                break :blk tmp;
+                tmp[tmp.len - 1] = 0;
+                break :blk @ptrCast(tmp);
             },
             .security => blk: {
                 const tmp = try alloc.alloc(u8, key_entry.name_size + 1 + 9);
                 errdefer alloc.free(tmp);
                 try meta.interface.readSliceEndian(u8, tmp[9 .. tmp.len - 1], .little);
-                @memset(tmp[0..9], "security.");
+                @memcpy(tmp[0..9], "security.");
-                break :blk tmp;
+                tmp[tmp.len - 1] = 0;
+                break :blk @ptrCast(tmp);
             },
         };
-        key[key.len - 1] = 0;
         errdefer alloc.free(key);
 
         if (key_entry.type.out_of_line) {
-            const value: ValueOutOfLineEntry = undefined;
+            var value: ValueOutOfLineEntry = undefined;
             try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
 
             out[i] = .{
@@ -95,10 +94,22 @@ pub fn get(self: *XattrCachedTable, alloc: std.mem.Allocator, io: Io, idx: u32)
             };
             continue;
         }
-        const val_ref: InodeRef = .{ .block_start = meta.cur_block_start, .block_offset = meta.interface.seek };
+        const val_ref: InodeRef = .{ .block_start = meta.cur_block_start, .block_offset = @truncate(meta.interface.seek) };
 
+        {
+            try self.value_mut.lockShared(io);
+            defer self.value_mut.unlockShared(io);
+            if (self.value_cache.contains(val_ref)) {
+                out[i] = .{
+                    .key = key,
+                    .value = try self.valueAt(io, val_ref),
+                };
+                continue;
+            }
+        }
         try self.value_mut.lock(io);
         defer self.value_mut.unlock(io);
+
         if (self.value_cache.contains(val_ref)) {
             out[i] = .{
                 .key = key,
@@ -108,7 +119,7 @@ pub fn get(self: *XattrCachedTable, alloc: std.mem.Allocator, io: Io, idx: u32)
         }
 
         var val_size: u32 = undefined;
-        try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
+        try meta.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
 
         const val = try self.alloc.alloc(u8, val_size);
         errdefer alloc.free(val);
@@ -129,12 +140,12 @@ fn valueAt(self: *XattrCachedTable, io: Io, ref: InodeRef) ![]const u8 {
 
     if (self.value_cache.contains(ref)) return self.value_cache.get(ref).?;
 
-    var rdr = try self.fil.readerAt(io, self.kv_start + ref.block_start, &[0]u8{});
+    var rdr = self.fil.readerAt(self.kv_start + ref.block_start);
-    var meta: MetadataReader = .init(self.alloc, &rdr.interface, self.decomp);
+    var meta: MetadataReader = .init(self.alloc, &rdr, self.decomp);
     try meta.interface.discardAll(ref.block_offset);
 
     var val_size: u32 = undefined;
-    try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
+    try meta.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
 
     const val = try self.alloc.alloc(u8, val_size);
     errdefer self.alloc.free(val);
@@ -201,15 +212,12 @@ const XattrPrefix = packed struct(u16) {
 
 // Stateless
 
-pub fn statelessLookup(alloc: std.mem.Allocator, io: Io, decomp: *const Decompressor, fil: OffsetFile, table_start: u64, idx: u16) ![]XattrOwned {
+pub fn statelessLookup(alloc: std.mem.Allocator, io: Io, decomp: *Decompressor, fil: OffsetFile, table_start: u64, idx: u16) ![]XattrOwned {
-    var rdr = try fil.readerAt(io, table_start, &[0]u8{});
+    const kv_start: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[table_start .. table_start + 8]), .little);
-
-    var kv_start: u64 = undefined;
-    try rdr.interface.readSliceEndian(u64, @ptrCast(&kv_start), .little);
 
     const lookup = try LookupTable.lookupValue(TableValue, alloc, io, decomp, fil, table_start + 16, idx);
 
-    rdr = try fil.readerAt(io, kv_start + lookup.ref.block_start, &[0]u8{});
+    var rdr = fil.readerAt(kv_start + lookup.ref.block_start);
     var meta: MetadataReader = .init(alloc, &rdr.interface, decomp);
     try meta.interface.discardAll(lookup.ref.block_offset);
 
@@ -250,7 +258,7 @@ pub fn statelessLookup(alloc: std.mem.Allocator, io: Io, decomp: *const Decompre
             const value: ValueOutOfLineEntry = undefined;
             try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
 
-            var ool_rdr = try fil.readerAt(io, kv_start + value.ref.block_start, &[0]u8{});
+            var ool_rdr = fil.readerAt(kv_start + value.ref.block_start);
             var ool_meta: MetadataReader = .init(alloc, &ool_rdr.interface, decomp);
             try ool_meta.interface.discardAll(value.ref.block_offset);