Added dedicated single_threaded mode for extraction

Cleanup

.zed/debug.json

@@ -11,7 +11,7 @@
 
 		"build": {
 			"command": "zig",
-			"args": ["build", "-Ddebug=true", "-Dstatic=true"],
+			"args": ["build", "-Ddebug=true"],
 		},
 
 		"program": "zig-out/bin/unsquashfs",

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 by 5x. Under ideal circumstances.
 * Performance improvements/regressions will be common. I'm still learning Zig.
 
 Example Times:
 
-* *unsquashfs, multi-threaded*: .12s
+* *unsquashfs, multi-threaded*: .15s
-* *unsquashfs, single-threaded*: .13s
+* *unsquashfs, single-threaded*: .16s
-* *C-libs, single-threaded*: .45s
+* *C-libs, single-threaded*: .36s
-* *C-libs, multi-threaded*: .20s
+* *C-libs, multi-threaded*: .14s
-* *Zig-libs, single-threaded*: 5.78s
+* *Zig-libs, single-threaded*: CURRENTLY UNTESTED
-* *Zig-libs, multi-threaded*: 1.08s
+* *Zig-libs, multi-threaded*: .76s
 
 ## 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,100 +1,142 @@
 const std = @import("std");
 
 pub fn build(b: *std.Build) !void {
-    const zig_decomp = b.option(bool, "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 static = b.option(bool, "static", "Statically link libraries.") orelse false;
+<<<<<<< HEAD
-    const debug = b.option(bool, "debug", "Enable options to make debugging easier.") orelse false;
+=======
-    const version_string_option = b.option([]const u8, "version", "Version of the library/binary") orelse "0.0.0-testing";
+    const dynamic = b.option(bool, "dynamic", "Dynamicly link C decompression libraries") orelse false;
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+    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();
+    zig_squashfs_options.addOption(bool, "use_zig_decomp", use_zig_decomp);
+    zig_squashfs_options.addOption(bool, "allow_lzo", allow_lzo);
 
     const target = b.standardTargetOptions(.{});
-    const optimize: std.builtin.OptimizeMode = if (debug) .Debug else b.standardOptimizeOption(.{});
+    var optimize = b.standardOptimizeOption(.{});
 
-    const version: std.SemanticVersion = try .parse(if (version_string_option[0] == 'v') version_string_option[1..] else version_string_option);
+    if (debug == true)
+        optimize = .Debug;
+    if (optimize == .Debug)
+        debug = true;
 
-    const build_config = b.addOptions();
+    const c = b.addTranslateC(.{
-    build_config.addOption(bool, "zig_decomp", zig_decomp);
-    build_config.addOption(bool, "allow_lzo", allow_lzo);
-    build_config.addOption(bool, "debug", debug);
-    build_config.addOption(std.SemanticVersion, "version", version);
-
-    const c_h = b.addTranslateC(.{
-        .target = target,
         .optimize = optimize,
+        .target = target,
         .root_source_file = b.path("src/c.h"),
     });
-    if (allow_lzo) c_h.defineCMacro("ALLOW_LZO", null);
-    const c = c_h.createModule();
-
-    if (static) {
-        const zng = b.dependency("zlib_ng", .{
-            .target = target,
-            .optimize = optimize,
-            .zlib_compat = true,
-        });
-        c.linkLibrary(zng.artifact("zng"));
-
-        const zstd = b.dependency("zstd", .{ .optimize = optimize, .target = target });
-        c.linkLibrary(zstd.artifact("zstd"));
-
-        const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
-        c.linkLibrary(lz4.artifact("lz4"));
-
-        const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
-        c.linkLibrary(xz.artifact("lzma"));
-
-        if (allow_lzo) {
-            const lzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
-            c.linkLibrary(lzo.artifact("minilzo"));
-        }
-    } else {
-        c.linkSystemLibrary("z", .{});
-        c.linkSystemLibrary("zstd", .{});
-        c.linkSystemLibrary("lz4", .{});
-        c.linkSystemLibrary("lzma", .{});
-        if (allow_lzo)
-            c.linkSystemLibrary("minilzo", .{});
-    }
 
     const lib = b.addLibrary(.{
         .name = "squashfs",
-        .root_module = b.addModule("zig_squashfs", .{
+        .root_module = b.createModule(.{
-            .root_source_file = b.path("src/root.zig"),
+            .optimize = if (debug == true) .Debug else optimize,
             .target = target,
-            .optimize = optimize,
             .valgrind = debug,
+            .root_source_file = b.path("src/root.zig"),
+<<<<<<< HEAD
+            // .link_libc = true,
             .imports = &.{
-                .{ .name = "c", .module = c },
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
-                .{ .name = "build_config", .module = build_config.createModule() },
+                .{ .name = "c", .module = c.createModule() },
+=======
+            .imports = &.{
+                .{ .name = "options", .module = zig_squashfs_options.createModule() },
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
             },
         }),
         .use_llvm = debug,
-        .version = version,
     });
 
+    const deps = try dependencies(b, optimize, target, use_zig_decomp, allow_lzo, dynamic);
+    defer b.allocator.free(deps);
+
+<<<<<<< HEAD
+    const zng = b.dependency("zlib_ng", .{ .optimize = optimize, .target = target });
+    lib.root_module.linkLibrary(zng.artifact("zng"));
+
+    const xz = b.dependency("xz", .{ .optimize = optimize, .target = target });
+    lib.root_module.linkLibrary(xz.artifact("lzma"));
+
+    const minilzo = b.dependency("minilzo", .{ .optimize = optimize, .target = target });
+    lib.root_module.linkLibrary(minilzo.artifact("minilzo"));
+
+    const lz4 = b.dependency("lz4", .{ .optimize = optimize, .target = target });
+    lib.root_module.linkLibrary(lz4.artifact("lz4"));
+=======
+    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);
+    }
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+
+    var version = version_string_option orelse "0.0.0-testing";
+    if (version[0] == 'v') version = version[1..];
+    const unsquashfs_options = b.addOptions();
+    unsquashfs_options.addOption(
+        std.SemanticVersion,
+        "version",
+        try std.SemanticVersion.parse(version),
+    );
     const exe = b.addExecutable(.{
         .name = "unsquashfs",
         .root_module = b.createModule(.{
-            .root_source_file = b.path("src/bin/unsquashfs.zig"),
+            .optimize = if (debug == true) .Debug else optimize,
             .target = target,
-            .optimize = optimize,
-            .imports = &.{
-                .{ .name = "squashfs", .module = lib.root_module },
-                .{ .name = "build_config", .module = build_config.createModule() },
-            },
             .valgrind = debug,
+            .root_source_file = b.path("src/bin/unsquashfs.zig"),
+            .imports = &.{
+                .{ .name = "zig_squashfs", .module = lib.root_module },
+            },
         }),
         .use_llvm = debug,
-        .version = version,
     });
+    exe.root_module.addOptions("config", unsquashfs_options);
 
     b.installArtifact(lib);
     b.installArtifact(exe);
 
     const mod_tests = b.addTest(.{
-        .root_module = lib.root_module,
+        .root_module = b.createModule(.{
+            .optimize = optimize,
+            .target = target,
+            .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);
@@ -102,15 +144,52 @@ pub fn build(b: *std.Build) !void {
     // zls build check steps
     const lib_check = b.addLibrary(.{
         .name = "squashfs",
-        .root_module = lib.root_module,
+        .root_module = exe.root_module,
-        .use_llvm = debug,
     });
     const exe_check = b.addExecutable(.{
         .name = "unsquashfs",
-        .root_module = exe.root_module,
+        .root_module = lib.root_module,
-        .use_llvm = debug,
     });
     const check = b.step("check", "Check if unsquashfs compiles");
     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

@@ -2,23 +2,27 @@
     .name = .squashfs,
     .version = "0.0.6",
     .fingerprint = 0x37ba29474b87f145, // Changing this has security and trust implications.
-    .minimum_zig_version = "0.16.0",
+    .minimum_zig_version = "0.15.2",
     .dependencies = .{
         .zlib_ng = .{
-            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#915db2dbd4a540d8a933336d67520b786f168f01",
+            .url = "git+https://github.com/CalebQ42/zig-zlib-ng#5f2f02dfb28acca2517dacbbd09e9b987f57b133",
-            .hash = "zlib_ng-2.3.3-pre1-2HYS4MlFAADc-eSZv4_xjkxZRCdGUVOYZKdtqhybstgk",
+            .hash = "zlib_ng-2.3.3-pre1-2HYS4ClFAABW8KlHMyBHtlNKE3V7kCS8wqfxawG7xeaa",
         },
         .zstd = .{
-            .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-2#4ccb01e6fceae86fb9fe36c60b8a103cdc058155",
+            .url = "git+https://github.com/allyourcodebase/zstd.git?ref=1.5.7-1#e1a501be57f42c541e8a5597e4b59a074dfd09a3",
-            .hash = "zstd-1.5.7-2-KEItkAMwAADNhCbGaImKrjXjnSA51jcqEbGCA3RasVZ9",
+            .hash = "zstd-1.5.7-1-KEItkAMwAAD6OKY3m0OOmXG7aL-aLUfrDqbP5J5oYapU",
         },
         .lz4 = .{
             .url = "git+https://github.com/allyourcodebase/lz4.git?ref=1.10.0-6#41f52ab227caf9d48cf88c89a4d2946caa12b102",
             .hash = "lz4-1.10.0-6-ewyzw-4NAAAWDpY4xpiqr4LQhZQAC0x_rGnW2iPh6jk2",
         },
         .minilzo = .{
-            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#f72a0e20a30fad38cd10104f393c8f3440478697",
+            .url = "git+https://github.com/CalebQ42/zig-minilzo.git#7cbae997b91a44d74b7cd6c073584dc9562a6c90",
-            .hash = "minilzo-2.10.0-Ij7BO7YLAABd6oK2YdimXwvFTOC8wD1sNm0PHGoRNEwR",
+            .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 = .{

src/archive.zig

@@ -1,84 +1,126 @@
 const std = @import("std");
 const Io = std.Io;
 
-const util = @import("utils/util.zig");
+const Decomp = @import("decomp.zig");
-
+const ExtractionOptions = @import("options.zig");
 const File = @import("file.zig");
 const Inode = @import("inode.zig");
-const Decomp = @import("decomp.zig");
+const LookupTable = @import("lookup_table.zig");
-const Options = @import("options.zig");
+const Decompressor = @import("util/decompressor.zig");
-const Decompress = @import("utils/decompress.zig");
+const MetadataReader = @import("util/metadata.zig");
+const Utils = @import("util/misc.zig");
+const OffsetFile = @import("util/offset_file.zig");
 
 const Archive = @This();
 
-map: Io.File.MemoryMap,
+file: OffsetFile,
+super: Superblock,
 
-super: Super,
+stateless_decomp: *const Decompressor,
-root_inode_ref: Inode.Reference,
 
-pub fn init(io: Io, file: Io.File, offset: u64) !Archive {
+pub fn init(io: Io, file: std.Io.File, offset: u64) !Archive {
-    var map = try file.createMemoryMap(io, .{
+    var rdr = file.reader(io, &[0]u8{});
-        .len = try file.length(io) - offset,
+    try rdr.seekTo(offset);
-        .offset = offset,
+    var super: Superblock = undefined;
-        .protection = .{ .read = true },
+    try rdr.interface.readSliceEndian(Superblock, @ptrCast(&super), .little);
-    });
+    try super.validate();
-
-    var superblock = util.readValue(Superblock, map.memory[0..@sizeOf(Superblock)]);
-    const super = try superblock.checkAndMinimize();
 
     return .{
-        .map = map,
+        .file = try .init(io, file, super.size, offset),
-
         .super = super,
-        .root_inode_ref = superblock.root_inode_ref,
+
+        .stateless_decomp = try Decomp.StatelessDecomp(super.compression),
     };
 }
 pub fn deinit(self: *Archive, io: Io) void {
-    self.map.destroy(io);
+    self.file.deinit(io);
 }
 
-pub fn root(self: *Archive, alloc: std.mem.Allocator) !File {
+/// The root folder of the Archive. Used to open other Files.
-    return .{
+pub fn root(self: Archive, alloc: std.mem.Allocator) !File {
-        .alloc = alloc,
+    const root_inode = try Utils.inodeFromRef(
-
-        .data = self.map.memory,
-        .super = self.super,
-
-        .inode = try .readLocation(
         alloc,
-            self.map.memory,
+        self.file,
-            self.root_inode_ref.start,
+        self.stateless_decomp,
-            self.root_inode_ref.offset,
+        self.super.inode_start,
-            self.super,
+        self.super.block_size,
-        ),
+        self.super.root_ref,
-        .name = "",
-    };
-}
-pub fn open(self: *Archive, alloc: std.mem.Allocator, filepath: []const u8) !File {
-    var root_file = try self.root(alloc);
-    defer root_file.deinit();
-
-    return root.open(alloc, filepath);
-}
-pub fn extract(self: *Archive, alloc: std.mem.Allocator, io: Io, ext_loc: []const u8, options: Options) !void {
-    const root_inode: Inode = try .readLocation(
-        alloc,
-        self.map.memory,
-        self.root_inode_ref.start,
-        self.root_inode_ref.offset,
-        self.super,
     );
+    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 {
+    const 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);
+}
 
-    if (options.single_threaded)
+/// Returns the inode with the given inode number.
-        return Decompress.single(alloc, io, self.map.memory, self.super, root_inode, ext_loc, options);
+/// Requires that the archive is exportable (has an export lookup table).
-    return Decompress.multi(alloc, io, self.map.memory, self.super, root_inode, ext_loc, options);
+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(
+        Inode.Ref,
+        alloc,
+        io,
+        &self.stateless_decomp,
+        self.file,
+        self.super.export_start,
+        num + 1,
+    );
+    return Utils.inodeFromRef(
+        alloc,
+        io,
+        self.file,
+        &self.stateless_decomp,
+        self.super.inode_start,
+        self.super.block_size,
+        ref,
+    );
+}
+/// 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 {
+    return LookupTable.lookupValue(
+        u16,
+        alloc,
+        io,
+        &self.stateless_decomp,
+        self.file,
+        self.super.id_start,
+        idx,
+    );
+}
+
+/// 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 Superblock = extern struct {
+const SQUASHFS_MAGIC: u32 = std.mem.readInt(u32, "hsqs", .little);
-    pub const MAGIC: u32 = 0x73717368;
 
+const SuperblockError = error{
+    InvalidMagic,
+    InvalidBlockLog,
+    InvalidVersion,
+    InvalidCheck,
+};
+
+/// A squashfs Superblock
+pub const Superblock = extern struct {
     magic: u32,
     inode_count: u32,
     mod_time: u32,
@@ -90,62 +132,157 @@ const Superblock = extern struct {
         inode_uncompressed: bool,
         data_uncompressed: bool,
         check: bool,
-        fragment_uncompressed: bool,
+        frag_uncompressed: bool,
         fragment_never: bool,
         fragment_always: bool,
-        de_duplicate: bool,
+        duplicates: bool,
         exportable: bool,
         xattr_uncompressed: bool,
         xattr_never: bool,
         compression_options: bool,
-        id_uncompressed: bool,
+        ids_uncompressed: bool,
         _: u4,
     },
     id_count: u16,
-    version_major: u16,
+    ver_maj: u16,
-    version_minor: u16,
+    ver_min: u16,
-    root_inode_ref: Inode.Reference,
+    root_ref: Inode.Ref,
     size: u64,
-    id_table_start: u64,
+    id_start: u64,
-    xattr_table_start: u64,
+    xattr_start: u64,
-    inode_table_start: u64,
+    inode_start: u64,
-    dir_table_start: u64,
+    dir_start: u64,
-    frag_table_start: u64,
+    frag_start: u64,
-    export_table_start: u64,
+    export_start: u64,
 
-    fn checkAndMinimize(self: Superblock) !Super {
+    /// Validate the Superblock. If an error is returned, it's likely the archive is corrupted or not a squashfs archive.
-        if (self.magic != MAGIC)
+    pub fn validate(self: Superblock) !void {
-            return error.InvalidMagic;
+        if (self.magic != SQUASHFS_MAGIC)
-        if (self.version_major != 4 or self.version_minor != 0)
+            return SuperblockError.InvalidMagic;
-            return error.IncompatibleVersion;
-        if (std.math.log2(self.block_size) != self.block_log)
-            return error.BadBlockLog;
         if (self.flags.check)
-            return error.BadCheckFlag;
+            return SuperblockError.InvalidCheck;
-
+        if (self.ver_maj != 4 or self.ver_min != 0)
-        return .{
+            return SuperblockError.InvalidVersion;
-            .block_size = self.block_size,
+        if (std.math.log2(self.block_size) != self.block_log)
-            .frag_count = self.frag_count,
+            return SuperblockError.InvalidBlockLog;
-            .decomp_fn = try self.compression.func(),
-            .id_count = self.id_count,
-            .id_table_start = self.id_table_start,
-            .xattr_table_start = self.xattr_table_start,
-            .inode_table_start = self.inode_table_start,
-            .dir_table_start = self.dir_table_start,
-            .frag_table_start = self.frag_table_start,
-            .export_table_start = self.export_table_start,
-        };
     }
 };
-pub const Super = struct {
+
-    block_size: u32,
+// Tests
-    frag_count: u32,
+
-    decomp_fn: Decomp.Fn,
+const TestArchive = "testing/LinuxPATest.sfs";
-    id_count: u16,
+
-    id_table_start: u64,
+test "Basics" {
-    xattr_table_start: u64,
+    std.debug.print("Starting test: Basics...\n", .{});
-    inode_table_start: u64,
+
-    dir_table_start: u64,
+    const alloc = std.testing.allocator;
-    frag_table_start: u64,
+    const io = std.testing.io;
-    export_table_start: u64,
+
+    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

@@ -1,11 +1,10 @@
 const std = @import("std");
 const Io = std.Io;
 const Writer = Io.Writer;
+const builtin = @import("builtin");
 
-const config = @import("build_config");
+const config = @import("config");
-const squashfs = @import("squashfs");
+const squashfs = @import("zig_squashfs");
-const Archive = squashfs.Archive;
-const Options = squashfs.Options;
 
 //TODO: Add more options
 const help_mgs =
@@ -19,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.
@@ -29,40 +28,122 @@ const help_mgs =
     \\
 ;
 
-var arc_loc: []const u8 = "";
+const errors = error{InvalidArguments};
-var ext_loc: []const u8 = "squashfs-root";
 
+var archive: []const u8 = "";
+var extLoc: []const u8 = "squashfs-root";
 var offset: u64 = 0;
-var threads: usize = 0;
+var threads: u32 = 0;
+var verbose: bool = false;
+var ignore_xattrs: bool = false;
+var ignore_permissions: bool = false;
 var force: bool = false;
 
-var options: Options = .default;
-
 pub fn main(init: std.process.Init) !void {
-    var io = init.io;
     const alloc = init.gpa;
+    const io = init.io;
 
-    // TODO: process args
+    var stdout = std.Io.File.stdout();
+    defer stdout.close(io);
+    var out = stdout.writer(io, &[0]u8{});
+    defer out.interface.flush() catch {};
 
-    var limited_io: Io.Threaded = undefined;
+    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: Handle error gracefully.
+    const options: squashfs.ExtractionOptions = .{
+        .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);
     if (threads != 0) {
-        limited_io = if (threads == 1)
+        var limited_io = Io.Threaded.init(alloc, .{
-            Io.Threaded.init_single_threaded
+            .async_limit = .limited(threads - 1),
-        else
+            .concurrent_limit = .limited(threads - 1),
-            Io.Threaded.init(alloc, .{
-                .async_limit = .limited(threads),
-                .concurrent_limit = .limited(threads),
             .argv0 = .init(init.minimal.args),
             .environ = init.minimal.environ,
         });
-        io = limited_io.io();
+        return arc.extract(alloc, limited_io.io(), extLoc, options); //TODO: Handle error gracefully.
+    }
+    return arc.extract(alloc, io, extLoc, options); //TODO: Handle error gracefully.
 }
 
-    var fil = try Io.Dir.cwd().openFile(io, arc_loc, .{});
+fn handleArgs(args: std.process.Args, out: *Writer) !void {
-    defer fil.close(io);
+    var arg_iter = args.iterate();
-
+    defer arg_iter.deinit();
-    var arc: Archive = try .open(io, fil, offset);
+    _ = arg_iter.next(); // args[0] is the application launch command.
-    defer arc.close(io);
+    while (arg_iter.next()) |arg| {
-
+        if (std.mem.eql(u8, arg, "-o")) {
-    try arc.extract(alloc, io, ext_loc, options);
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-o must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            }
+            offset = std.fmt.parseInt(u64, nxt.?, 10) catch {
+                try out.print("-o must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            };
+            continue;
+        } else if (std.mem.eql(u8, arg, "-d")) {
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-d must be followed by a location\n", .{});
+                return errors.InvalidArguments;
+            }
+            extLoc = nxt.?;
+            continue;
+        } else if (std.mem.eql(u8, arg, "-p")) {
+            const nxt = arg_iter.next();
+            if (nxt == null or nxt.?.len == 0) {
+                try out.print("-p must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            }
+            threads = std.fmt.parseInt(u32, nxt.?, 10) catch {
+                try out.print("-p must be followed by a number\n", .{});
+                return errors.InvalidArguments;
+            };
+            continue;
+        } else if (std.mem.eql(u8, arg, "-v")) {
+            verbose = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "-dx")) {
+            ignore_xattrs = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "-dp")) {
+            ignore_permissions = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "--force")) {
+            force = true;
+            continue;
+        } else if (std.mem.eql(u8, arg, "--version")) {
+            try out.print("zig-unsquashfs v", .{});
+            try config.version.format(out);
+            try out.print("\nBuilt using Zig {s} in {} mode\n", .{ builtin.zig_version_string, builtin.mode });
+            std.process.exit(0);
+            return;
+        } else if (std.mem.eql(u8, arg, "--help")) {
+            try out.print(help_mgs, .{});
+            std.process.exit(0);
+            return;
+        }
+        if (archive.len > 0) {
+            try out.print("you can only provide one file at a time\n", .{});
+            try out.print(help_mgs, .{});
+            return errors.InvalidArguments;
+        }
+        archive = arg;
+    }
 }

src/c.h

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

src/decomp.zig

@@ -1,8 +1,22 @@
 const std = @import("std");
 const Io = std.Io;
 
-const c = @import("c");
+const options = @import("options");
-const build = @import("build_config");
+
+const lzma = @import("decomp/zig_lzma.zig");
+const xz = @import("decomp/zig_xz.zig");
+const Decompressor = @import("util/decompressor.zig");
+
+const zlib = if (options.use_zig_decomp) @import("decomp/zig_zlib.zig") else @import("decomp/c_zlib.zig");
+<<<<<<< HEAD
+const lzo = if (options.use_zig_decomp or !options.allow_lzo) void else @import("decomp/c_lzo.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");
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+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,
@@ -11,138 +25,80 @@ pub const Enum = enum(u16) {
     xz,
     lz4,
     zstd,
+};
 
-    pub fn func(self: Enum) !Fn {
+pub fn StatelessDecomp(val: Enum) !*const Decompressor {
-        return switch (self) {
+    return switch (val) {
-            .gzip => if (build.zig_decomp) zigZlib else cZlib,
+        .gzip => &zlib.stateless_decompressor,
-            .lzma => if (build.zig_decomp) zigLzma else cLzma,
+        .lzma => &lzma.stateless_decompressor,
-            .lzo => if (build.zig_decomp or !build.allow_lzo) error.LzoUnsupported else cLzo,
+        .lzo => if (options.use_zig_decomp or !options.allow_lzo)
-            .xz => if (build.zig_decomp) zigXz else cXz,
+            error.LzoUnsupported
-            .lz4 => if (build.zig_decomp) error.Lz4Unsupported else cLz4,
+        else
-            .zstd => if (build.zig_decomp) zigZstd else cZstd,
+            &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,
+
+<<<<<<< HEAD
+    pub fn init(val: Enum, alloc: std.mem.Allocator, io: std.Io, block_size: u32) !Decomp {
+        return switch (val) {
+            .gzip => .{ .gzip = zlib.init(alloc, io, block_size) },
+            .lzma => .{ .lzma = .{} },
+            .lzo => .{ .lzo = .{} },
+            .xz => .{ .xz = .{} },
+            .lz4 => .{ .lz4 = .{} },
+            .zstd => .{ .zstd = zstd.init(alloc, io, block_size) },
+=======
+    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) },
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+        };
+    }
+    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) *const Decompressor {
+        return switch (self.*) {
+            .gzip => &self.gzip.interface,
+            .lzma => &lzma.stateless_decompressor,
+            .lzo => if (options.use_zig_decomp or !options.allow_lzo) unreachable else &lzo.stateless_decompressor,
+            .xz => &xz.stateless_decompressor,
+            .lz4 => if (options.use_zig_decomp) unreachable else &lz4.stateless_decompressor,
+            .zstd => &self.zstd.interface,
         };
     }
 };
-pub const Fn = *const fn (alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize;
-
-pub const Error = Io.Reader.Error || std.mem.Allocator.Error;
-
-// Actual decomp functions
-
-fn zigZlib(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var rdr: Io.Reader = .fixed(in);
-    var decomp: std.compress.flate.Decompress = .init(&rdr, .zlib, &[0]u8{});
-
-    return decomp.reader.readSliceShort(out);
-}
-fn cZlib(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.z_stream = .{
-        .avail_in = @truncate(in.len),
-        .next_in = in.ptr,
-        .avail_out = @truncate(out.len),
-        .next_out = out.ptr,
-    };
-    const res = c.inflate(&stream, c.Z_FULL_FLUSH);
-    if (res != c.Z_OK)
-        return Error.ReadFailed;
-    return stream.total_out;
-}
-
-fn zigLzma(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var rdr: Io.Reader = .fixed(in);
-
-    var decomp: std.compress.lzma.Decompress = .initOptions(&rdr, alloc, &[0]u8{}, .{}, 0);
-    defer decomp.deinit();
-
-    return decomp.reader.readSliceShort(out);
-}
-fn cLzma(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.lzma_stream = .{
-        .avail_in = in.len,
-        .next_in = in.ptr,
-        .avail_out = out.len,
-        .next_out = out.ptr,
-    };
-    defer c.lzma_end(&stream);
-
-    var res = c.lzma_alone_decoder(&stream, 0);
-    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;
-}
-
-fn cLzo(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var res = c.lzo_init();
-    if (res != c.LZO_E_OK)
-        return Error.ReadFailed;
-
-    var len = out.len;
-    res = c.lzo1x_decompress(in.ptr, in.len, out.ptr, &len, null);
-    if (res != c.LZO_E_OK)
-        return Error.ReadFailed;
-
-    return Error.ReadFailed;
-}
-
-fn zigXz(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var rdr: Io.Reader = .fixed(in);
-
-    var decomp: std.compress.xz.Decompress = .init(&rdr, alloc, &[0]u8{});
-    defer decomp.deinit();
-
-    return decomp.reader.readSliceShort(out);
-}
-fn cXz(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var stream: c.lzma_stream = .{
-        .avail_in = in.len,
-        .next_in = in.ptr,
-        .avail_out = out.len,
-        .next_out = out.ptr,
-    };
-    defer c.lzma_end(&stream);
-
-    var res = c.lzma_stream_decoder(&stream, 0, 0);
-    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;
-}
-
-fn cLz4(_: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    const res = c.LZ4_decompress_safe(in.ptr, out.ptr, @intCast(in.len), @intCast(out.len));
-    if (res < 0) return Error.ReadFailed;
-
-    return @abs(res);
-}
-
-fn zigZstd(alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
-    var rdr: Io.Reader = .fixed(in);
-
-    const buf = try alloc.alloc(u8, 1024 * 1024);
-    defer alloc.free(buf);
-
-    var decomp: std.compress.zstd.Decompress = .init(&rdr, buf, .{
-        .window_len = 1024 * 1024,
-    });
-
-    return decomp.reader.readSliceShort(out);
-}
-fn cZstd(_: 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) == 1) {
-        std.debug.print("{s}\n", .{c.ZSTD_getErrorName(res)});
-        return Error.ReadFailed;
-    }
-    return res;
-}

src/decomp/c_lz4.zig

@@ -0,0 +1,19 @@
+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 };
+
+fn statelessDecomp(_: ?*const Decompressor, _: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+<<<<<<< HEAD
+    const res = c.LZ4_decompress_fast(in.ptr, out.ptr, @truncate(out.len));
+=======
+    const out_len: c_int = @bitCast(@as(u32, @truncate(out.len)));
+    const res = c.LZ4_decompress_fast(in.ptr, out.ptr, out_len);
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+    if (res < 0) return Error.ReadFailed;
+    return @abs(res);
+}

src/decomp/c_lzma.zig

@@ -0,0 +1,44 @@
+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 };
+
+fn statelessDecomp(_: ?*const 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,24 @@
+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 };
+
+fn statelessDecomp(_: ?*const 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,45 @@
+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 };
+
+fn statelessDecomp(_: ?*const 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,97 @@
+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: ?*const 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(_: ?*const 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;
+}
+
+// zalloc
+
+fn zalloc(ptr: ?*anyopaque, size: c_uint, len: c_uint) callconv(.c) ?*anyopaque {
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    return alloc.rawAlloc(size * len, .@"1", 0);
+}
+fn zfree(ptr: ?*anyopaque, mem_ptr: ?*anyopaque) callconv(.c) void {
+<<<<<<< HEAD
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    alloc.rawFree(@ptrCast(mem_ptr), .@"1", 0);
+=======
+    if (mem_ptr == null) return;
+    var alloc: *std.mem.Allocator = @ptrCast(@alignCast(ptr));
+    alloc.free(@as([*]u8, @ptrCast(mem_ptr.?)));
+>>>>>>> dfbfbda (Build is working again (on Zig master branch))
+}

src/decomp/c_zstd.zig

@@ -0,0 +1,71 @@
+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: ?*const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    // TODO: Fix
+    //
+    // 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(_: ?*const 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/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: ?*const 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(_: ?*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/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: ?*const 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(_: ?*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_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: ?*const 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(_: ?*const 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

@@ -0,0 +1,73 @@
+const std = @import("std");
+const Io = std.Io;
+const Reader = std.Io.Reader;
+const zstd = std.compress.zstd;
+
+const Decompressor = @import("../util/decompressor.zig");
+const Error = Decompressor.Error;
+
+const Queue = std.Io.Queue([]u8);
+
+const Self = @This();
+
+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, 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));
+
+    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: ?*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 zstdDecomp(buf, 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 zstdDecomp(buf, in, out);
+}
+
+inline fn zstdDecomp(buffer: []u8, in: []u8, out: []u8) !usize {
+    var rdr: Reader = .fixed(in);
+    var d = zstd.Decompress.init(&rdr, buffer, .{ .window_len = @truncate(out.len) });
+
+    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, out.len + zstd.block_size_max);
+    defer alloc.free(buf);
+    return zstdDecomp(buf, in, out);
+}

src/dir.zig

@@ -1,74 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const utils = @import("utils/util.zig");
-
-const Inode = @import("inode.zig");
-
-const Directory = @This();
-
-entries: []Entry,
-
-pub fn read(alloc: std.mem.Allocator, rdr: *Io.Reader, size: u32) !Directory {
-    var red: u32 = 3;
-
-    var out: std.ArrayList(Entry) = try .initCapacity(alloc, 10);
-    errdefer out.deinit(alloc);
-
-    while (red < size) {
-        const hdr: Header = try utils.readValueRdr(Header, rdr);
-        red += @sizeOf(Header);
-
-        try out.ensureUnusedCapacity(alloc, hdr.count + 1);
-
-        for (0..hdr.count + 1) |_| {
-            const raw: RawEntry = try utils.readValueRdr(RawEntry, rdr);
-
-            const name = try alloc.alloc(u8, raw.name_size + 1);
-            errdefer alloc.free(name);
-
-            try rdr.readSliceAll(name);
-
-            out.addOneAssumeCapacity().* = .{
-                .start = hdr.start,
-                .offset = raw.offset,
-                .type = raw.type,
-                .name = name,
-            };
-
-            red += @sizeOf(RawEntry) + raw.name_size + 1;
-        }
-    }
-
-    return .{ .entries = try out.toOwnedSlice(alloc) };
-}
-pub fn deinit(self: Directory, alloc: std.mem.Allocator) void {
-    for (self.entries) |entry|
-        entry.deinit(alloc);
-
-    alloc.free(self.entries);
-}
-
-// Types
-
-pub const Entry = struct {
-    start: u32,
-    offset: u16,
-    type: Inode.Type,
-    name: []const u8,
-
-    pub fn deinit(self: Entry, alloc: std.mem.Allocator) void {
-        alloc.free(self.name);
-    }
-};
-const Header = extern struct {
-    count: u32,
-    start: u32,
-    inode_num: u32,
-};
-const RawEntry = extern struct {
-    offset: u16,
-    inode_num_offset: i16,
-    type: Inode.Type,
-    name_size: u16,
-};

src/directory.zig

@@ -0,0 +1,69 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+
+const Inode = @import("inode.zig");
+
+pub const Error = error{OutOfMemory} || Reader.Error;
+
+const DirEntry = @This();
+
+block_start: u32,
+block_offset: u16,
+type: Inode.Type,
+name: []const u8,
+
+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) Error![]DirEntry {
+    var hdr: Header = undefined;
+    var raw: RawEntry = undefined;
+    var out: std.ArrayList(DirEntry) = try .initCapacity(alloc, 30);
+    errdefer {
+        for (out.items) |ent|
+            alloc.free(ent.name);
+        out.deinit(alloc);
+    }
+
+    var tot_red: u32 = 3;
+    while (tot_red < size) {
+        try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
+        try out.ensureUnusedCapacity(alloc, hdr.count + 1);
+
+        tot_red += @sizeOf(Header);
+
+        for (0..hdr.count + 1) |_| {
+            try rdr.readSliceEndian(RawEntry, @ptrCast(&raw), .little);
+
+            const new_name = try alloc.alloc(u8, raw.name_size + 1);
+            try rdr.readSliceEndian(u8, new_name, .little);
+
+            const new = out.addOneAssumeCapacity();
+            new.* = .{
+                .block_start = hdr.block_start,
+                .block_offset = raw.block_offset,
+                .type = raw.type,
+                .name = new_name,
+            };
+
+            tot_red += @sizeOf(RawEntry) + raw.name_size + 1;
+        }
+    }
+    return out.toOwnedSlice(alloc);
+}
+
+// Types
+
+const Header = extern struct {
+    count: u32,
+    block_start: u32,
+    num: u32,
+};
+
+const RawEntry = extern struct {
+    block_offset: u16,
+    num_offset: i16,
+    type: Inode.Type,
+    name_size: u16,
+};

src/file.zig

@@ -1,158 +1,94 @@
+//! An easier to use wrapper around an inode.
+
 const std = @import("std");
 const Io = std.Io;
 
+const Archive = @import("archive.zig");
+const DirEntry = @import("directory.zig");
+const ExtractionOptions = @import("options.zig");
 const Inode = @import("inode.zig");
-const Directory = @import("dir.zig");
+const DataExtractor = @import("util/data_extractor.zig");
-const MetadataReader = @import("utils/meta.zig");
+const Decompressor = @import("util/decompressor.zig");
-const Options = @import("options.zig");
+const MetadataReader = @import("util/metadata.zig");
-const DataReader = @import("utils/data_reader.zig");
+const SharedCache = @import("util/shared_cache.zig");
-const Decompress = @import("utils/decompress.zig");
-const Super = @import("archive.zig").Super;
 
 const File = @This();
 
 alloc: std.mem.Allocator,
 
-data: []u8,
+archive: Archive,
-super: Super,
 
-name: []const u8,
 inode: Inode,
+name: []const u8,
 
-pub fn copy(self: File, alloc: std.mem.Allocator) !File {
+/// Creates a new File from an inode. Takes ownership of the Inode and creates a copy of the given name.
-    const new_name = try alloc.dupe(u8, self.name);
+/// Requires the given allocator was used to create the Inode.
-    errdefer alloc.free(new_name);
+pub fn init(alloc: std.mem.Allocator, archive: Archive, in: Inode, name: []const u8) !File {
-
+    const new_name = try alloc.alloc(u8, name.len);
+    @memcpy(new_name, name);
     return .{
         .alloc = alloc,
 
-        .data = self.data,
+        .archive = archive,
-        .super = self.super,
 
+        .inode = in,
         .name = new_name,
-        .inode = try self.inode.copy(alloc),
     };
 }
+pub fn fromDirEntry(alloc: std.mem.Allocator, archive: Archive, ent: DirEntry) !File {
+    var rdr = archive.file.readerAt(archive.super.inode_start + ent.block_start);
+    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);
+}
 pub fn deinit(self: File) void {
-    self.inode.deinit(self.alloc);
     self.alloc.free(self.name);
+    self.inode.deinit(self.alloc);
 }
 
-/// Reader interface to read a regular file's contents.
+pub fn open(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8) !File {
-pub fn reader(self: File, alloc: std.mem.Allocator) !DataReader {
+    const entries = try self.inode.readDirectory(
-    return switch (self.inode.header.type) {
-        .file => |f| .init(
         alloc,
-            self.data,
+        self.archive.file,
-            self.super.decomp_fn,
+        self.archive.stateless_decomp,
-            self.super.block_size,
+        self.archive.super.dir_start,
-            f.start,
-            f.size,
-            f.blocks,
-        ),
-        .ext_file => |f| .init(
-            alloc,
-            self.data,
-            self.super.decomp_fn,
-            self.super.block_size,
-            f.start,
-            f.size,
-            f.blocks,
-        ),
-        else => error.NotRegularFile,
-    };
-}
-
-pub fn open(self: File, alloc: std.mem.Allocator, filepath: []const u8) !File {
-    switch (self.inode.header.type) {
-        .dir, .ext_dir => {},
-        else => return error.NotDirectory,
-    }
-
-    const path = std.mem.trim(u8, filepath, "/");
-
-    if (path.len == 0 or (path.len == 1 and path[0] == '.'))
-        return self.copy(alloc);
-
-    const first_element: []const u8 = std.mem.sliceTo(path, '/');
-    const final = first_element.len == path.len;
-
-    var dir_rdr: MetadataReader = .init(alloc, self.data[self.inode.data.dir.start + self.super.dir_table_start ..], self.super.decomp_fn);
-    try dir_rdr.interface.discardAll(self.inode.data.dir.offset);
-
-    const dir_size = self.inode.data.dir.size;
-
-    const entry: Directory.Entry = blk: {
-        var dir: Directory = try .read(alloc, &dir_rdr.interface, dir_size);
-        defer dir.deinit(alloc);
-
-        var entries = dir.entries;
-        var idx: usize = undefined;
-
-        while (entries.len > 1) {
-            idx = entries.len / 2;
-            const val = entries[idx];
-
-            switch (std.mem.order(u8, first_element, val.name)) {
-                .eq => break,
-                .lt => entries = entries[0..idx],
-                .gt => entries = entries[idx..],
-            }
-        } else {
-            if (!std.mem.eql(u8, first_element, entries[0].name))
-                return error.NotFound;
-            idx = 0;
-        }
-
-        if (!final) break :blk entries[idx];
-
-        const inode: Inode = try .readLocation(
-            alloc,
-            self.data,
-            entries[idx].start,
-            entries[idx].offset,
-            self.super,
     );
-        errdefer inode.deinit(alloc);
+    defer {
+        for (entries) |ent|
+            alloc.free(ent.name);
+        alloc.free(entries);
+    }
+    const path = std.mem.trim(u8, filepath, "/");
+    const first_element: []const u8 = std.mem.sliceTo(path, '/');
 
-        return .{
+    var search_slice = entries;
-            .alloc = alloc,
+    var idx: usize = undefined;
+    while (search_slice.len > 0) {
+        idx = search_slice.len / 2;
+        const middle = search_slice[idx];
+        switch (std.mem.order(u8, first_element, middle.name)) {
+            .eq => break,
+            .lt => search_slice = search_slice[0..idx],
+            .gt => search_slice = search_slice[idx + 1 ..],
+        }
+    } else return Error.FileNotFound;
 
-            .data = self.data,
+    const first_elem_file = try fromDirEntry(alloc, self.archive, search_slice[idx]);
-            .super = self.super,
+    if (first_element.len == path.len)
-
+        return first_elem_file;
-            .inode = inode,
+    defer first_elem_file.deinit();
-            .name = try alloc.dupe(u8, entries[idx].name),
+    return first_elem_file.open(alloc, io, path[first_element.len + 1 ..]);
-        };
-    };
-
-    if (entry.type != .dir)
-        return error.NotFound;
-
-    const transient_file: File = .{
-        .alloc = alloc,
-
-        .data = self.data,
-        .super = self.super,
-
-        .inode = try .readLocation(
-            alloc,
-            self.data,
-            entry.start,
-            entry.offset,
-            self.super,
-        ),
-        .name = "",
-    }; // We don't care about deiniting this file since dir inodes don't need to be deinited and we don't have an allocd name.
-
-    return transient_file.open(alloc, path[first_element.len + 1 ..]);
 }
 
-/// Extract the given File to the location.
+pub fn extract(self: File, alloc: std.mem.Allocator, io: Io, filepath: []const u8, options: ExtractionOptions) !void {
-pub fn extract(self: File, alloc: std.mem.Allocator, io: Io, ext_loc: []const u8, options: Options) !void {
+    return self.inode.extract(alloc, io, self.archive.file, self.archive.super, filepath, options);
-    // TODO: do some basic processing to check if ext_loc is a folder & if self is regular file and adjust accordingly.
-
-    if (options.single_threaded)
-        return Decompress.single(alloc, io, self.map.memory, self.super, self.inode, ext_loc, options);
-    return Decompress.multi(alloc, io, self.map.memory, self.super, self.inode, ext_loc, options);
 }
+
+// Types
+
+pub const Error = error{
+    FileNotFound,
+} || Inode.Error;

src/frag.zig

@@ -0,0 +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: *const 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: *const 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/frag_cache.zig

@@ -1,72 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Lookup = @import("lookup.zig");
-const Decomp = @import("decomp.zig");
-const BlockSize = @import("inode.zig").BlockSize;
-
-const FragCache = @This();
-
-block_size: u32,
-
-entries: Lookup.Table(Entry),
-
-cache: std.AutoHashMapUnmanaged(u32, CacheData) = .empty,
-
-mut: Io.Mutex = .init,
-
-pub fn init(data: []u8, decomp: Decomp.Fn, block_size: u32, start: u64, count: u32) !FragCache {
-    return .{
-        .block_size = block_size,
-
-        .entries = try .init(data, decomp, start, count),
-    };
-}
-pub fn deinit(self: *FragCache, alloc: std.mem.Allocator) void {
-    self.entries.deinit(alloc);
-    var iter = self.cache.valueIterator();
-    while (iter.next()) |cache| {
-        if (cache.allocd)
-            alloc.free(cache.data);
-    }
-    self.cache.deinit(alloc);
-}
-
-pub fn get(self: *FragCache, alloc: std.mem.Allocator, io: Io, idx: u32) ![]u8 {
-    const cache = self.cache.get(idx);
-    if (cache != null) return cache.?.data;
-
-    const entry = try self.entries.get(alloc, io, idx);
-
-    const data = self.entries.data[entry.start..][0..entry.size.size];
-
-    if (entry.size.uncompressed)
-        return data;
-
-    try self.mut.lock(io);
-    defer self.mut.unlock(io);
-
-    const cache_data = try alloc.alloc(u8, self.block_size);
-    errdefer alloc.free(cache_data);
-
-    _ = try self.entries.decomp(alloc, data, cache_data);
-
-    try self.cache.put(alloc, idx, .{
-        .data = cache_data,
-        .allocd = true,
-    });
-
-    return cache_data;
-}
-
-// Types
-
-pub const Entry = extern struct {
-    start: u64,
-    size: BlockSize,
-    _: u32,
-};
-const CacheData = struct {
-    data: []u8,
-    allocd: bool,
-};

src/inode.zig

@@ -1,71 +1,166 @@
+//! A file-system object. Represents a File or directory.
+
 const std = @import("std");
+const Reader = std.Io.Reader;
 const Io = std.Io;
 
-const util = @import("utils/util.zig");
+const Archive = @import("archive.zig");
-
+const Decomp = @import("decomp.zig").Decomp;
-const MetadataReader = @import("utils/meta.zig");
+const DirEntry = @import("directory.zig");
-const Super = @import("archive.zig").Super;
+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();
 
-header: Header,
+hdr: Header,
 data: Data,
 
-pub fn readLocation(alloc: std.mem.Allocator, data: []u8, start: u32, offset: u16, super: Super) !Inode {
+pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !Inode {
-    var meta: MetadataReader = .init(alloc, data[super.inode_table_start + start ..], super.decomp_fn);
+    var hdr: Header = undefined;
-    try meta.interface.discardAll(offset);
+    try rdr.readSliceEndian(Header, @ptrCast(&hdr), .little);
-
-    return read(alloc, &meta.interface, super.block_size);
-}
-pub fn read(alloc: std.mem.Allocator, rdr: *Io.Reader, block_size: u32) !Inode {
-    const hdr = try util.readValueRdr(Header, rdr);
-
     return .{
-        .header = hdr,
+        .hdr = hdr,
-        .data = switch (hdr.type) {
+        .data = switch (hdr.inode_type) {
-            .dir => .{ .dir = try .readBasic(rdr) },
+            .dir => .{ .dir = try .read(rdr) },
-            .ext_dir => .{ .dir = try .readExt(rdr) },
+            .file => .{ .file = try .read(alloc, rdr, block_size) },
-            .file => .{ .file = try .readBasic(rdr, alloc, block_size) },
+            .symlink => .{ .symlink = try .read(alloc, rdr) },
-            .ext_file => .{ .file = try .readExt(rdr, alloc, block_size) },
+            .block_dev => .{ .block_dev = try .read(rdr) },
-            .symlink, .ext_symlink => .{ .symlink = try .read(rdr, alloc) },
+            .char_dev => .{ .char_dev = try .read(rdr) },
-            .block_dev, .char_dev => .{ .dev = try .readBasic(rdr) },
+            .fifo => .{ .fifo = try .read(rdr) },
-            .ext_block_dev, .ext_char_dev => .{ .dev = try .readExt(rdr) },
+            .socket => .{ .socket = try .read(rdr) },
-            .fifo, .socket => .{ .fifo = try .readBasic(rdr) },
+            .ext_dir => .{ .ext_dir = try .read(rdr) },
-            .ext_fifo, .ext_socket => .{ .fifo = try .readExt(rdr) },
+            .ext_file => .{ .ext_file = try .read(alloc, rdr, block_size) },
+            .ext_symlink => .{ .ext_symlink = try .read(alloc, rdr) },
+            .ext_block_dev => .{ .ext_block_dev = try .read(rdr) },
+            .ext_char_dev => .{ .ext_char_dev = try .read(rdr) },
+            .ext_fifo => .{ .ext_fifo = try .read(rdr) },
+            .ext_socket => .{ .ext_socket = try .read(rdr) },
         },
     };
 }
-pub fn copy(self: Inode, alloc: std.mem.Allocator) !Inode {
-    var new_inode = self;
-
-    switch (new_inode.data) {
-        .file => |*f| f.blocks = try alloc.dupe(BlockSize, f.blocks),
-        .symlink => |*f| f.target = try alloc.dupe(u8, f.target),
-        else => {},
-    }
-
-    return new_inode;
-}
 pub fn deinit(self: Inode, alloc: std.mem.Allocator) void {
     switch (self.data) {
-        .file => |f| alloc.free(f.blocks),
+        .file => |d| d.deinit(alloc),
-        .symlink => |s| alloc.free(s.target),
+        .symlink => |d| d.deinit(alloc),
+        .ext_file => |d| d.deinit(alloc),
+        .ext_symlink => |d| d.deinit(alloc),
         else => {},
     }
 }
 
+// Utility Functions
+
+/// Read the directory entries
+pub fn readDirectory(self: Inode, alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64) ![]DirEntry {
+    return switch (self.data) {
+        .dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
+        .ext_dir => |d| readDirFromData(alloc, fil, decomp, dir_offset, d),
+        else => Error.NotDirectory,
+    };
+}
+fn readDirFromData(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, dir_offset: u64, d: anytype) ![]DirEntry {
+    var rdr = fil.readerAt(dir_offset + d.block_start);
+    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 {
+    return switch (self.data) {
+        .file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, f),
+        .ext_file => |f| getReaderFromData(alloc, io, fil, cache, decomp, block_size, 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 {
+    const ext: DataReader = .init(alloc, io, fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+    if (d.frag_block_offset == 0xFFFFFFFF) {
+        // TODO:
+        return error.TODO;
+    }
+    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 {
+    return switch (self.data) {
+        .file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
+        .ext_file => |f| getExtractorFromData(fil, cache, decomp, block_size, f),
+        else => Error.NotRegularFile,
+    };
+}
+fn getExtractorFromData(fil: OffsetFile, cache: *SharedCache, decomp: *const Decompressor, block_size: u32, d: anytype) !DataExtractor {
+    const ext: DataExtractor = .init(fil, cache, decomp, block_size, d.size, d.block_start, d.blocks);
+    if (d.frag_block_offset == 0xFFFFFFFF) {
+        // TODO:
+        return error.TODO;
+    }
+    return ext;
+}
+/// Get a symlink's target path
+pub fn symlinkTarget(self: Inode) ![]const u8 {
+    return switch (self.data) {
+        .symlink => |s| s.target,
+        .ext_symlink => |s| s.target,
+        else => Error.NotSymlink,
+    };
+}
+/// 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 {
+    return LookupTable.lookupValue(u16, alloc, io, decomp, fil, id_table_start, self.hdr.gid_idx);
+}
+/// 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 {
+    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 {
+    const idx = 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 => return error.NoXattr,
+    };
+    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: *const 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);
+}
+
 // Types
 
-pub const Reference = packed struct(u64) {
+pub const Error = error{
-    offset: u16,
+    NotDirectory,
-    start: u32,
+    NotRegularFile,
-    _: u16,
+    NotSymlink,
+    NotExtended,
 };
 
-pub const BlockSize = packed struct(u32) {
+pub const Ref = packed struct(u64) {
-    size: u23,
+    block_offset: u16,
-    uncompressed: bool,
+    block_start: u32,
-    _: u8,
+    _: u16 = 0,
 };
 
 pub const Type = enum(u16) {
@@ -85,218 +180,456 @@ pub const Type = enum(u16) {
     ext_socket,
 };
 
+pub const Data = union(Type) {
+    dir: dir.Dir,
+    file: file.File,
+    symlink: misc.Symlink,
+    block_dev: misc.Dev,
+    char_dev: misc.Dev,
+    fifo: misc.IPC,
+    socket: misc.IPC,
+    ext_dir: dir.ExtDir,
+    ext_file: file.ExtFile,
+    ext_symlink: misc.ExtSymlink,
+    ext_block_dev: misc.ExtDev,
+    ext_char_dev: misc.ExtDev,
+    ext_fifo: misc.ExtIPC,
+    ext_socket: misc.ExtIPC,
+};
+
 pub const Header = extern struct {
-    type: Type,
+    inode_type: Type,
-    permission: u16,
+    permissions: u16,
     uid_idx: u16,
     gid_idx: u16,
     mod_time: u32,
-    inode_num: u32,
+    num: u32,
 };
 
-pub const Data = union(enum) {
+// Extract
-    dir: Dir,
-    file: File,
-    symlink: Symlink,
-    dev: Dev,
-    fifo: Fifo,
-};
 
-// Inode data types
+const ExtractError = error{ MknodFailed, CannotSetXattr } || DataExtractor.Error || DirEntry.Error ||
+    Decompressor.Error || Io.File.Atomic.InitError || Io.File.Atomic.LinkError || Io.Dir.SymLinkError;
+const PathRet = struct {
+    path: []const u8,
+    inode: Inode,
+    origin: bool,
 
-pub const Dir = struct {
+    fn deinit(self: PathRet, alloc: std.mem.Allocator) void {
-    //RegularDir structure:
+        if (self.origin) return;
-    //    start: u32,
+        alloc.free(self.path);
-    //    hard_links: u32,
+        self.inode.deinit(alloc);
-    //    size: u16,
-    //    offset: u16,
-    //    parent_inode_num: u32,
-    // ExtDir structure
-    //    hard_links: u32,
-    //    size: u32,
-    //    start: u32,
-    //    parent_inode_num: u32,
-    //    idx_count: u16,
-    //    offset: u16,
-    //    xattr_idx: u32,
-    //    dir_indexes: []DirIndex,
-
-    hard_links: u32,
-    size: u32,
-    start: u32,
-    offset: u16,
-    xattr_idx: ?u32,
-
-    pub fn readBasic(rdr: *Io.Reader) !Dir {
-        var raw: [12]u8 = undefined;
-        try rdr.readSliceAll(&raw);
-
-        return .{
-            .start = util.readValue(u32, raw[0..4]),
-            .hard_links = util.readValue(u32, raw[4..8]),
-            .size = util.readValue(u16, raw[8..10]),
-            .offset = util.readValue(u16, raw[10..12]),
-            .xattr_idx = null,
-        };
     }
-    pub fn readExt(rdr: *Io.Reader) !Dir {
+    fn setMetadata(self: PathRet, alloc: std.mem.Allocator, io: Io, id_table: *CachedTable(u16), xattr_table: ?*XattrTable, options: ExtractionOptions) !void {
-        var raw: [24]u8 = undefined;
+        var fil = try Io.Dir.cwd().openFile(io, self.path, .{});
-        try rdr.readSliceAll(&raw);
+        defer fil.close(io);
 
-        return .{
+        const inode = self.inode;
-            .hard_links = util.readValue(u32, raw[0..4]),
+
-            .size = util.readValue(u32, raw[4..8]),
+        if (!options.ignore_permissions) {
-            .start = util.readValue(u32, raw[8..12]),
+            try fil.setPermissions(io, @enumFromInt(inode.hdr.permissions));
-            .offset = util.readValue(u16, raw[18..20]),
+            try fil.setOwner(io, try id_table.get(io, inode.hdr.uid_idx), try id_table.get(io, inode.hdr.gid_idx));
-            .xattr_idx = util.readValue(u32, raw[20..24]),
+        }
-        };
+        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),
+    frag: LookupTable.CachedTable(FragEntry),
+    xattr: XattrTable,
+};
 
-pub const File = struct {
+/// Extracts the given inode to the given path. If the inode not a directory, the given path must not exist.
-    //RegularFile structure:
+/// If the inode is a directory the path must not exist or be a directory.
-    //    start: u32,
+pub fn extract(
-    //    frag_idx: u32,
+    self: Inode,
-    //    frag_offset: u32,
+    alloc: std.mem.Allocator,
-    //    size: u32,
+    io: Io,
-    //    block_sizes: []BlockSize,
+    fil: OffsetFile,
-    //ExtFile structure:
+    super: Archive.Superblock,
-    //    start: u64,
+    filepath: []const u8,
-    //    size: u64,
+    options: ExtractionOptions,
-    //    sparse: u64,
+) !void {
-    //    hard_links: u32,
+    const path = std.mem.trimEnd(u8, filepath, "/");
-    //    frag_idx: u32,
-    //    frag_offset: u32,
-    //    xattr_idx: u32,
-    //    block_sizes: []BlockSize,
 
-    start: u64,
+    var decomp_base: Decomp = try .init(super.compression, alloc, io, super.block_size);
-    frag_idx: u32,
+    decomp_base.deinit(alloc);
-    frag_offset: u32,
+    const decomp = decomp_base.decompressor();
-    size: u64,
-    blocks: []BlockSize,
-    xattr_idx: ?u32,
 
-    pub fn readBasic(rdr: *Io.Reader, alloc: std.mem.Allocator, block_size: u32) !File {
+    var frag_mgr: FragManager = try .init(alloc, fil, decomp, super.frag_start, super.frag_count, super.block_size);
-        var raw: [16]u8 = undefined;
+    defer frag_mgr.deinit(io);
-        try rdr.readSliceAll(&raw);
 
-        const frag_idx = util.readValue(u32, raw[4..8]);
+    if (options.single_threaded)
-        const size = util.readValue(u32, raw[12..16]);
+        return self.extractSinglethreaded(alloc, io, fil, super, path, options, decomp, &frag_mgr);
 
-        const block_num = if (frag_idx == 0xFFFFFFFF)
+    var sel_buf: [10]ExtractReturnUnion = undefined;
-            try std.math.divCeil(usize, size, block_size)
+    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: *const 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,
+            };
+
+            try ext.extractAsync(alloc, io, atomic.file);
+
+            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;
+        },
+    }
+    return .{
+        .path = path,
+        .inode = self,
+        .origin = origin,
+    };
+}
+fn finishLoop(alloc: std.mem.Allocator, io: Io, fil: OffsetFile, decomp: *const Decompressor, super: Archive.Superblock, options: ExtractionOptions, sel: *Io.Select(ExtractReturnUnion)) !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
-            size / block_size;
+        try .init(alloc, fil, decomp, super.xattr_start);
+    defer if (xattr_table != null) xattr_table.?.deinit(io);
 
-        const sizes = try alloc.alloc(BlockSize, block_num);
+    var dir_queue: std.PriorityDequeue(PathRet, void, DirCompare) = .empty;
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
+    defer dir_queue.deinit(alloc);
 
-        return .{
+    while (true) {
-            .start = util.readValue(u32, raw[0..4]),
+        if (sel.group.token.load(.unordered) == null) break;
-            .frag_idx = frag_idx,
+
-            .frag_offset = util.readValue(u32, raw[8..12]),
+        const ret = try sel.await();
-            .size = size,
+        const path_ret = try ret.path_ret;
-            .blocks = sizes,
+
-            .xattr_idx = null,
+        if (options.ignore_permissions and xattr_table == null) {
-        };
+            path_ret.deinit(alloc);
+            continue;
         }
-    pub fn readExt(rdr: *Io.Reader, alloc: std.mem.Allocator, block_size: u32) !File {
-        var raw: [40]u8 = undefined;
-        try rdr.readSliceAll(&raw);
 
-        const frag_idx = util.readValue(u32, raw[28..32]);
+        if (path_ret.inode.hdr.inode_type == .dir or path_ret.inode.hdr.inode_type == .ext_dir) {
-        const size = util.readValue(u64, raw[8..16]);
+            try dir_queue.push(alloc, path_ret);
+            continue;
+        }
+        defer path_ret.deinit(alloc);
 
-        const block_num = if (frag_idx == 0xFFFFFFFF)
+        try path_ret.setMetadata(alloc, io, &id_table, if (xattr_table == null) null else &xattr_table.?, options);
-            try std.math.divCeil(usize, size, block_size)
+    }
+
+    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: *const 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
-            size / block_size;
+        try .init(alloc, fil, decomp, super.xattr_start);
+    defer if (xattr_table != null) xattr_table.?.deinit(io);
 
-        const sizes = try alloc.alloc(BlockSize, block_num);
+    return self.extractReal(
-        try rdr.readSliceEndian(BlockSize, sizes, .little);
+        alloc,
-
+        io,
-        return .{
+        fil,
-            .start = util.readValue(u64, raw[0..8]),
+        super,
-            .size = size,
+        decomp,
-            .frag_idx = frag_idx,
+        frag,
-            .frag_offset = util.readValue(u32, raw[32..36]),
+        &id_table,
-            .blocks = sizes,
+        if (xattr_table == null) null else &xattr_table.?,
-            .xattr_idx = util.readValue(u32, raw[36..40]),
+        path,
-        };
+        options,
+    );
 }
+fn extractReal(
+    self: Inode,
+    alloc: std.mem.Allocator,
+    io: Io,
+    fil: OffsetFile,
+    super: Archive.Superblock,
+    decomp: *const 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 {
-pub const Symlink = struct {
+                for (entries) |e|
-    hard_links: u32,
+                    e.deinit(alloc);
-    target: []const u8,
+                alloc.free(entries);
-    // xattr_idx is ignored on extended symlinks as you can't apply them to symlinks anyway.
-
-    pub fn read(rdr: *Io.Reader, alloc: std.mem.Allocator) !Symlink {
-        var raw: [8]u8 = undefined;
-        try rdr.readSliceAll(&raw);
-
-        const target = try alloc.alloc(u8, std.mem.readInt(u32, raw[4..], .little));
-        errdefer alloc.free(target);
-
-        try rdr.readSliceEndian(u8, target, .little);
-
-        return .{
-            .hard_links = std.mem.readInt(u32, raw[0..4], .little),
-            .target = target,
-        };
             }
-};
 
-pub const Dev = struct {
+            for (entries) |e| {
-    hard_links: u32,
+                const new_path = try std.mem.concat(alloc, u8, &[_][]const u8{ path, "/", e.name });
-    device: u32,
+                defer alloc.free(new_path);
-    // xattr_idx omitted on basic device inodes.
-    xattr_idx: ?u32,
 
-    pub fn readBasic(rdr: *Io.Reader) !Dev {
+                var rdr = fil.readerAt(super.inode_start + e.block_start);
-        var raw: [8]u8 = undefined;
+                var meta: MetadataReader = .init(alloc, &rdr, decomp);
-        try rdr.readSliceAll(&raw);
+                try meta.interface.discardAll(e.block_offset);
 
-        return .{
+                const new_inode = try read(alloc, &meta.interface, super.block_size);
-            .hard_links = util.readValue(u32, raw[0..4]),
+                defer new_inode.deinit(alloc);
-            .device = util.readValue(u32, raw[4..8]),
+
-            .xattr_idx = null,
+                try new_inode.extractReal(alloc, io, fil, super, decomp, frag_mgr, id_table, xattr_table, new_path, options);
-        };
             }
-    pub fn readExt(rdr: *Io.Reader) !Dev {
+        },
-        var raw: [12]u8 = undefined;
+        .file, .ext_file => {
-        try rdr.readSliceAll(&raw);
+            var atomic = try Io.Dir.cwd().createFileAtomic(io, path, .{ .make_path = true });
+            defer atomic.deinit(io);
 
-        return .{
+            var rdr: DataReader = switch (self.data) {
-            .hard_links = util.readValue(u32, raw[0..4]),
+                .file => |f| blk: {
-            .device = util.readValue(u32, raw[4..8]),
+                    var ext: DataReader = try .init(alloc, io, fil, decomp, super.block_size, f.size, f.block_start, f.block_sizes);
-            .xattr_idx = util.readValue(u32, raw[8..12]),
+                    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,
             }
-};
 
-pub const Fifo = struct {
+            const sentinel_path = try std.mem.concatWithSentinel(alloc, u8, &[_][]const u8{path}, 0);
-    hard_links: u32,
+            const res = std.os.linux.mknod(sentinel_path, mode, dev);
-    // Xattr_idx omitted on basic fifo inodes.
+            alloc.free(sentinel_path);
-    xattr_idx: ?u32,
+            if (res != 0)
-
+                return ExtractError.MknodFailed;
-    pub fn readBasic(rdr: *Io.Reader) !Fifo {
+        },
-        var raw: [4]u8 = undefined;
-        try rdr.readSliceAll(&raw);
-
-        return .{
-            .hard_links = util.readValue(u32, raw[0..4]),
-            .xattr_idx = null,
-        };
     }
-    pub fn readExt(rdr: *Io.Reader) !Fifo {
+    if (options.ignore_permissions and options.ignore_xattr) return;
-        var raw: [8]u8 = undefined;
-        try rdr.readSliceAll(&raw);
 
-        return .{
+    var f = try Io.Dir.cwd().openFile(io, path, .{});
-            .hard_links = util.readValue(u32, raw[0..4]),
+    defer f.close(io);
-            .xattr_idx = util.readValue(u32, raw[4..8]),
+
-        };
+    if (!options.ignore_permissions) {
+        try f.setPermissions(io, @enumFromInt(self.hdr.permissions));
+        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

@@ -0,0 +1,32 @@
+const Reader = @import("std").Io.Reader;
+
+pub const Dir = extern struct {
+    block_start: u32,
+    hard_links: u32,
+    size: u16,
+    block_offset: u16,
+    parent_num: u32,
+
+    pub fn read(rdr: *Reader) !Dir {
+        var d: Dir = undefined;
+        try rdr.readSliceEndian(Dir, @ptrCast(&d), .little);
+        return d;
+    }
+};
+
+pub const ExtDir = extern struct {
+    hard_links: u32,
+    size: u32,
+    block_start: u32,
+    parent_num: u32,
+    idx_count: u16,
+    block_offset: u16,
+    xattr_idx: u32,
+    // index: []DirIndex
+
+    pub fn read(rdr: *Reader) !ExtDir {
+        var d: ExtDir = undefined;
+        try rdr.readSliceEndian(ExtDir, @ptrCast(&d), .little);
+        return d;
+    }
+};

src/inode_data/file.zig

@@ -0,0 +1,97 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+
+pub const BlockSize = packed struct(u32) {
+    size: u24,
+    uncompressed: bool,
+    _: u7,
+};
+
+const FileRawRead = extern struct {
+    block_start: u32,
+    frag_idx: u32,
+    frag_block_offset: u32,
+    size: u32,
+};
+
+pub const File = struct {
+    block_start: u32,
+    frag_idx: u32,
+    frag_block_offset: u32,
+    size: u32,
+    block_sizes: []BlockSize,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !File {
+        var raw: FileRawRead = undefined;
+        try rdr.readSliceEndian(FileRawRead, @ptrCast(&raw), .little);
+
+        var num_blocks: u32 = raw.size / block_size;
+        if (raw.size % block_size != 0 and raw.frag_idx == 0xFFFFFFFF)
+            num_blocks += 1;
+
+        const sizes = try alloc.alloc(BlockSize, num_blocks);
+        errdefer alloc.free(sizes);
+        try rdr.readSliceEndian(BlockSize, sizes, .little);
+
+        return .{
+            .block_start = raw.block_start,
+            .frag_idx = raw.frag_idx,
+            .frag_block_offset = raw.frag_block_offset,
+            .size = raw.size,
+            .block_sizes = sizes,
+        };
+    }
+
+    pub fn deinit(self: File, alloc: std.mem.Allocator) void {
+        alloc.free(self.block_sizes);
+    }
+};
+
+const ExtFileRawRead = extern struct {
+    block_start: u64,
+    size: u64,
+    sparse: u64,
+    hard_links: u32,
+    frag_idx: u32,
+    frag_block_offset: u32,
+    xattr_idx: u32,
+};
+
+pub const ExtFile = struct {
+    block_start: u64,
+    size: u64,
+    sparse: u64,
+    hard_links: u32,
+    frag_idx: u32,
+    frag_block_offset: u32,
+    xattr_idx: u32,
+    block_sizes: []BlockSize,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader, block_size: u32) !ExtFile {
+        var raw: ExtFileRawRead = undefined;
+        try rdr.readSliceEndian(ExtFileRawRead, @ptrCast(&raw), .little);
+
+        var num_blocks: u32 = @truncate(raw.size / block_size);
+        if (raw.size % block_size != 0 and raw.frag_idx == 0xFFFFFFFF)
+            num_blocks += 1;
+
+        const sizes = try alloc.alloc(BlockSize, num_blocks);
+        errdefer alloc.free(sizes);
+        try rdr.readSliceEndian(BlockSize, sizes, .little);
+
+        return .{
+            .block_start = raw.block_start,
+            .size = raw.size,
+            .sparse = raw.sparse,
+            .hard_links = raw.hard_links,
+            .frag_idx = raw.frag_idx,
+            .frag_block_offset = raw.frag_block_offset,
+            .xattr_idx = raw.xattr_idx,
+            .block_sizes = sizes,
+        };
+    }
+
+    pub fn deinit(self: ExtFile, alloc: std.mem.Allocator) void {
+        alloc.free(self.block_sizes);
+    }
+};

src/inode_data/misc.zig

@@ -0,0 +1,98 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+
+pub const Symlink = struct {
+    hard_links: u32,
+    target: []const u8,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !Symlink {
+        var start: [8]u8 = undefined;
+        try rdr.readSliceAll(&start);
+        const target_size = std.mem.readInt(u32, start[4..8], .little);
+        const target = try alloc.alloc(u8, target_size + 1);
+        errdefer alloc.free(target);
+        try rdr.readSliceEndian(u8, target, .little);
+        return .{
+            .hard_links = std.mem.readInt(u32, start[0..4], .little),
+            .target = target,
+        };
+    }
+
+    pub fn deinit(self: Symlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
+    }
+};
+
+pub const ExtSymlink = struct {
+    hard_links: u32,
+    target: []const u8,
+    xattr_idx: u32,
+
+    pub fn read(alloc: std.mem.Allocator, rdr: *Reader) !ExtSymlink {
+        var start: [8]u8 = undefined;
+        try rdr.readSliceAll(&start);
+        const target_size = std.mem.readInt(u32, start[4..8], .little);
+        const target = try alloc.alloc(u8, target_size + 1);
+        errdefer alloc.free(target);
+        try rdr.readSliceEndian(u8, target, .little);
+        var xattr_idx: u32 = undefined;
+        try rdr.readSliceEndian(u32, @ptrCast(&xattr_idx), .little);
+        return .{
+            .hard_links = std.mem.readInt(u32, start[0..4], .little),
+            .target = target,
+            .xattr_idx = xattr_idx,
+        };
+    }
+
+    pub fn deinit(self: ExtSymlink, alloc: std.mem.Allocator) void {
+        alloc.free(self.target);
+    }
+};
+
+/// A block or character device.
+pub const Dev = extern struct {
+    hard_links: u32,
+    dev: u32,
+
+    pub fn read(rdr: *Reader) !Dev {
+        var d: Dev = undefined;
+        try rdr.readSliceEndian(Dev, @ptrCast(&d), .little);
+        return d;
+    }
+};
+
+/// An extended block or character device.
+pub const ExtDev = extern struct {
+    hard_links: u32,
+    dev: u32,
+    xattr_idx: u32,
+
+    pub fn read(rdr: *Reader) !ExtDev {
+        var d: ExtDev = undefined;
+        try rdr.readSliceEndian(ExtDev, @ptrCast(&d), .little);
+        return d;
+    }
+};
+
+/// A socket or FIFO file.
+pub const IPC = extern struct {
+    hard_links: u32,
+
+    pub fn read(rdr: *Reader) !IPC {
+        var d: IPC = undefined;
+        try rdr.readSliceEndian(IPC, @ptrCast(&d), .little);
+        return d;
+    }
+};
+
+/// An extended socket or FIFO file.
+pub const ExtIPC = extern struct {
+    hard_links: u32,
+    xattr_idx: u32,
+
+    pub fn read(rdr: *Reader) !ExtIPC {
+        var d: ExtIPC = undefined;
+        try rdr.readSliceEndian(ExtIPC, @ptrCast(&d), .little);
+        return d;
+    }
+};

src/lookup.zig

@@ -1,179 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Decomp = @import("decomp.zig");
-const Reference = @import("inode.zig").Reference;
-const MetadataReader = @import("utils/meta.zig");
-const util = @import("utils/util.zig");
-
-pub fn Value(comptime T: type, alloc: std.mem.Allocator, data: []u8, decomp: Decomp.Fn, table_start: u64, idx: u32) !T {
-    const ITEMS_PER_BLOCK = 8192 / @sizeOf(T);
-
-    const block_idx = idx / ITEMS_PER_BLOCK;
-    const value_idx = idx % ITEMS_PER_BLOCK;
-
-    const start = util.readValue(u64, data[table_start + (block_idx * 8) ..][0..8]);
-
-    var meta: MetadataReader = .init(alloc, data[start..], decomp);
-    try meta.interface.discardAll(value_idx * @sizeOf(T));
-
-    return util.readValueRdr(T, &meta.interface);
-}
-
-pub fn Table(comptime T: type) type {
-    return struct {
-        const Self = @This();
-
-        const ITEMS_PER_BLOCK = 8192 / @sizeOf(T);
-
-        data: []u8,
-        decomp: Decomp.Fn,
-
-        start: u64,
-        count: u32,
-        block_count: u32,
-
-        table: std.hash_map.AutoHashMapUnmanaged(u32, []T) = .empty,
-        mut: Io.Mutex = .init,
-
-        pub fn init(data: []u8, decomp: Decomp.Fn, start: u64, count: u32) !Self {
-            return .{
-                .data = data,
-                .decomp = decomp,
-
-                .start = start,
-                .count = count,
-                .block_count = try std.math.divCeil(u32, count, ITEMS_PER_BLOCK),
-            };
-        }
-        pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
-            var iter = self.table.valueIterator();
-            while (iter.next()) |block|
-                alloc.free(block.*);
-
-            self.table.deinit(alloc);
-        }
-
-        pub fn get(self: *Self, alloc: std.mem.Allocator, io: Io, idx: u32) !T {
-            if (idx >= self.count) return error.InvalidIndex;
-
-            const block_idx = idx / ITEMS_PER_BLOCK;
-            const value_idx = idx % ITEMS_PER_BLOCK;
-
-            const init_get = self.table.get(block_idx);
-            if (init_get != null) return init_get.?[value_idx];
-
-            try self.mut.lock(io);
-            defer self.mut.unlock(io);
-
-            const start = util.readValue(u64, self.data[self.start + (block_idx * 8) ..][0..8]);
-
-            const len = if (block_idx == self.block_count - 1) self.count % ITEMS_PER_BLOCK else ITEMS_PER_BLOCK;
-
-            const new_block = try alloc.alloc(T, len);
-            errdefer alloc.free(new_block);
-
-            var meta: MetadataReader = .init(alloc, self.data[start..], self.decomp);
-
-            try meta.interface.readSliceEndian(T, new_block, .little);
-
-            try self.table.put(alloc, block_idx, new_block);
-
-            return new_block[value_idx];
-        }
-    };
-}
-
-pub const Xattr = struct {
-    kv_start: u64,
-    lookup: Table(XattrLookup),
-
-    pub fn init(data: []u8, decomp: Decomp.Fn, start: u64) !Xattr {
-        const kv_start = util.readValue(u64, data[start..][0..8]);
-        const count = util.readValue(u32, data[start..][8..12]);
-
-        return .{
-            .kv_start = kv_start,
-            .lookup = try .init(data, decomp, start + 16, count),
-        };
-    }
-    pub fn deinit(self: *Xattr, alloc: std.mem.Allocator) void {
-        self.lookup.deinit(alloc);
-    }
-
-    pub fn get(self: *Xattr, alloc: std.mem.Allocator, io: Io, idx: u32) ![]KV {
-        const lookup = try self.lookup.get(alloc, io, idx);
-
-        var meta: MetadataReader = .init(alloc, self.lookup.data[self.kv_start + lookup.ref.start ..], self.lookup.decomp);
-        try meta.interface.discardAll(lookup.ref.offset);
-
-        const kvs = try alloc.alloc(KV, lookup.count);
-        errdefer alloc.free(kvs);
-
-        for (kvs) |*kv| {
-            const entry = try util.readValueRdr(KeyEntry, &meta.interface);
-
-            const prefix = switch (entry.type.type) {
-                .user => "user.",
-                .trusted => "trusted.",
-                .security => "security.",
-            };
-
-            kv.name = try alloc.allocSentinel(u8, entry.name_size + prefix.len, 0);
-            errdefer alloc.free(kv.name);
-
-            try meta.interface.readSliceEndian(u8, kv.name[prefix.len..], .little);
-
-            @memcpy(kv.name[0..prefix.len], prefix);
-
-            var value_meta = if (entry.type.out_of_line) blk: {
-                const ool_ref = try util.readValueRdr(Reference, &meta.interface);
-
-                var ool_meta: MetadataReader = .init(alloc, self.lookup.data[self.kv_start + ool_ref.start ..], self.lookup.decomp);
-                try ool_meta.interface.discardAll(ool_ref.offset);
-
-                break :blk ool_meta;
-            } else meta;
-
-            const value_len = try util.readValueRdr(u32, &value_meta.interface);
-
-            kv.value = try alloc.alloc(u8, value_len);
-            errdefer alloc.free(kv.value);
-
-            try value_meta.interface.readSliceEndian(u8, kv.value, .little);
-        }
-
-        return kvs;
-    }
-
-    //types
-
-    pub const KV = struct {
-        name: [:0]u8,
-        value: []u8,
-
-        pub fn deinit(self: KV, alloc: std.mem.Allocator) void {
-            alloc.free(self.name);
-            alloc.free(self.value);
-        }
-    };
-
-    const XattrLookup = extern struct {
-        ref: Reference,
-        count: u32,
-        size: u32,
-    };
-
-    const KeyEntry = extern struct {
-        type: packed struct(u16) {
-            type: enum(u8) {
-                user,
-                trusted,
-                security,
-            },
-            out_of_line: bool,
-            _: u7,
-        },
-        name_size: u16,
-    };
-};

src/lookup_table.zig

@@ -0,0 +1,125 @@
+const std = @import("std");
+const Io = std.Io;
+
+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, decomp: *const 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;
+
+    const offset_pos = table_start + (8 * block);
+    const offset: u64 = std.mem.readInt(u64, @ptrCast(file.map.memory[offset_pos .. offset_pos + 8]), .little);
+
+    var rdr = file.readerAt(offset);
+    var meta: MetadataReader = .init(alloc, &rdr, decomp);
+
+    try meta.interface.discardAll(@sizeOf(T) * block_offset);
+    var out: T = undefined;
+    try meta.interface.readSliceEndian(T, @ptrCast(&out), .little);
+    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);
+
+        const Table = @This();
+
+        alloc: std.mem.Allocator,
+        fil: OffsetFile,
+        decomp: *const Decompressor,
+
+        table_start: u64,
+        total_num: u32,
+
+        table: std.AutoHashMap(u32, []T),
+
+        mut: Io.RwLock = .init,
+
+        pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, offset: u64, total_num: u32) Table {
+            return .{
+                .alloc = alloc,
+                .fil = fil,
+                .decomp = decomp,
+
+                .table_start = offset,
+                .total_num = total_num,
+
+                .table = .init(alloc),
+            };
+        }
+        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 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);
+
+            if (self.table.contains(block))
+                return self.table.get(block).?[block_offset];
+
+            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, self.decomp);
+
+            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

@@ -1,21 +1,29 @@
+//! Options for file/directory extraction.
+
 const std = @import("std");
 const Writer = std.Io.Writer;
 
-const Options = @This();
+const ExtractionOptions = @This();
 
+/// Extract single-threaded only.
+/// 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.
+ignore_xattr: bool = false,
+/// Replace symlinks with their target.
+dereference_symlinks: bool = false,
+/// Verbose logging. If true, verbose_writer must be set
 verbose: bool = false,
+/// Where to print verbose log.
 verbose_writer: ?*Writer = null,
 
-ignore_permissions: bool = false,
+pub const default: ExtractionOptions = .{};
-ignore_xattr: bool = false,
+pub const default_single_threaded: ExtractionOptions = .{ .single_threaded = true };
 
-dereference_symlink: bool = false,
+pub fn VerboseDefault(wrt: *Writer) !ExtractionOptions {
-
-single_threaded: bool = false,
-
-pub const default: Options = .{};
-pub const single_threaded_default: Options = .{ .single_threaded = true };
-pub fn verboseDefault(wrt: *Writer) Options {
     return .{
         .verbose = true,
         .verbose_writer = wrt,

src/root.zig

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

src/tests.zig

@@ -1,39 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-var alloc = std.testing.allocator;
-var io = std.testing.io;
-
-const Archive = @import("archive.zig");
-
-const TEST_ARCHIVE = "testing/LinuxPATest.sfs";
-
-const OPEN_TEST_LOCATION = "PortableApps/gVimPortable/GVim-v8.2.2965.glibc2.15-x86_64.AppImage";
-
-test "Open" {
-    var archive_file = try Io.Dir.cwd().openFile(io, TEST_ARCHIVE, .{});
-    defer archive_file.close(io);
-
-    var arc: Archive = try .init(io, archive_file, 0);
-    defer arc.deinit(io);
-
-    var root = try arc.root(alloc);
-    defer root.deinit();
-
-    var test_open = try root.open(alloc, OPEN_TEST_LOCATION);
-    defer test_open.deinit();
-}
-
-const FULL_EXTRACT_LOCATION = "testing/TestExtractST";
-
-test "FullExtractSingleThreaded" {
-    Io.Dir.cwd().deleteTree(io, FULL_EXTRACT_LOCATION) catch {};
-
-    var archive_file = try Io.Dir.cwd().openFile(io, TEST_ARCHIVE, .{});
-    defer archive_file.close(io);
-
-    var arc: Archive = try .init(io, archive_file, 0);
-    defer arc.deinit(io);
-
-    try arc.extract(alloc, io, FULL_EXTRACT_LOCATION, .default);
-}

src/util/data_extractor.zig

@@ -0,0 +1,162 @@
+//! The DataExtractor is meant to extract a regular file's data to a given file asyncronously.
+
+const std = @import("std");
+const Io = std.Io;
+
+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");
+
+pub const Error = Decompressor.Error || Io.File.MemoryMap.CreateError || Io.File.WritePositionalError;
+
+const DataExtractor = @This();
+
+fil: OffsetFile,
+decomp: *const Decompressor,
+block_size: u32,
+
+file_size: u64,
+start: u64,
+blocks: []BlockSize,
+
+frag_offset: u32 = 0,
+frag_block: ?[]u8 = null,
+
+err: ?Error = null,
+
+pub fn init(fil: OffsetFile, decomp: *const Decompressor, block_size: u32, file_size: u64, data_start: u64, blocks: []BlockSize) DataExtractor {
+    return .{
+        .fil = fil,
+        .decomp = decomp,
+        .block_size = block_size,
+
+        .file_size = file_size,
+        .start = data_start,
+        .blocks = blocks,
+    };
+}
+pub fn addFrag(self: *DataExtractor, frag_offset: u32, block: []u8) void {
+    self.frag_offset = frag_offset;
+    self.frag_block = block;
+}
+
+fn numBlocks(self: DataExtractor) usize {
+    var num = self.blocks.len;
+    if (self.frag_block != null) num += 1;
+    return num;
+}
+
+/// Starts extracting the data using the given group to spawn async tasks.
+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| {
+        try group.concurrent(io, blockThread, .{ self, alloc, io, fil, read_offset, idx, &err });
+        read_offset += self.blocks[idx].size;
+    }
+    if (self.frag_block != null)
+        try group.concurrent(io, fragThread, .{ self, io, fil, &err });
+
+    group.await(io) catch |cancel| return err orelse cancel;
+}
+
+/// 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)
+        self.file_size % self.block_size
+    else
+        self.block_size;
+
+    const write_offset = self.block_size * idx;
+
+    var wrt = fil.writer(io, &[0]u8{});
+    wrt.seekTo(write_offset) catch |err| {
+        ret_err.* = err;
+        if (err == error.Canceled) io.recancel();
+        return Io.Cancelable.Canceled;
+    };
+
+    if (block.size == 0) {
+        wrt.interface.splatByteAll(0, cur_block_size) catch |err| {
+            ret_err.* = err;
+            if (err == error.Canceled) io.recancel();
+            return Io.Cancelable.Canceled;
+        };
+    } else {
+        if (block.uncompressed) {
+            wrt.interface.writeAll(self.fil.map.memory[read_offset..][0..cur_block_size]) catch |err| {
+                ret_err.* = err;
+                if (err == error.Canceled) io.recancel();
+                return Io.Cancelable.Canceled;
+            };
+        } else {
+            @branchHint(.likely);
+
+            var tmp: [1024 * 1024]u8 = undefined;
+
+            _ = self.decomp.Decompress(alloc, self.fil.map.memory[read_offset..][0..block.size], tmp[0..cur_block_size]) catch |err| {
+                ret_err.* = err;
+                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, io: Io, fil: Io.File, ret_err: *?Error) Io.Cancelable!void {
+    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{});
+    wrt.seekTo(write_offset) catch |err| {
+        ret_err.* = err;
+        if (err == error.Canceled) io.recancel();
+        return Io.Cancelable.Canceled;
+    };
+
+    wrt.interface.writeAll(self.frag_block.?[self.frag_offset..][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;
+    };
+}

src/util/data_reader.zig

@@ -0,0 +1,189 @@
+//! DataReader reads a regular file's data linearly from start to finish using Io.Reader interface.
+
+const std = @import("std");
+const Io = std.Io;
+const Reader = Io.Reader;
+const Writer = Io.Writer;
+const Limit = Io.Limit;
+
+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 DataReader = @This();
+
+alloc: std.mem.Allocator,
+
+fil: OffsetFile,
+io: Io,
+decomp: *const Decompressor,
+block_size: u32,
+
+file_size: u64,
+cur_offset: u64,
+blocks: []BlockSize,
+
+frag_offset: u32 = 0,
+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 {
+    return .{
+        .alloc = alloc,
+
+        .fil = fil,
+        .io = io,
+        .decomp = decomp,
+        .block_size = block_size,
+
+        .file_size = file_size,
+        .cur_offset = data_start,
+        .blocks = blocks,
+
+        .interface = .{
+            .buffer = try alloc.alloc(u8, block_size),
+            .seek = 0,
+            .end = 0,
+            .vtable = &.{
+                .stream = stream,
+                .discard = discard,
+                .readVec = readVec,
+            },
+        },
+    };
+}
+pub fn deinit(self: *DataReader) void {
+    self.alloc.free(self.interface.buffer);
+}
+pub fn addFrag(self: *DataReader, frag_offset: u32, block: []u8) void {
+    self.frag_offset = frag_offset;
+    self.frag_block = block;
+}
+
+fn numBlocks(self: DataReader) usize {
+    var num = self.blocks.len;
+    if (self.frag_block != null) num += 1;
+    return num;
+}
+fn advanceBuffer(self: *DataReader) !void {
+    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.file_size % self.block_size
+    else
+        self.block_size;
+
+    // Fragment
+    if (self.block_idx == self.blocks.len) {
+        @memcpy(self.interface.buffer[0..self.interface.end], self.frag_block.?[self.frag_offset .. self.frag_offset + self.interface.end]);
+        self.interface.seek = 0;
+        return;
+    }
+
+    // Normal Block
+    const block = self.blocks[self.block_idx];
+    if (block.size == 0) {
+        self.interface.seek = 0;
+        self.sparse_block = true;
+        return;
+    } else {
+        self.sparse_block = false;
+    }
+    if (block.uncompressed) {
+        @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);
+
+        _ = 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]);
+        self.cur_offset += block.size;
+    }
+    self.interface.seek = 0;
+}
+
+fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) Reader.StreamError!usize {
+    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    if (rdr.seek == rdr.end)
+        data.advanceBuffer() catch |err| return switch (err) {
+            error.ReadFailed => error.ReadFailed,
+            error.EndOfStream => error.EndOfStream,
+            else => error.ReadFailed,
+        };
+
+    switch (limit) {
+        .nothing => return 0,
+        .unlimited => {
+            const wrote = if (data.sparse_block)
+                try wrt.splatByte(0, rdr.end - rdr.seek)
+            else
+                try wrt.write(rdr.buffer[rdr.seek..rdr.end]);
+            rdr.seek += wrote;
+            return wrote;
+        },
+        else => {
+            const to_read = @min(rdr.end - rdr.seek, @intFromEnum(limit));
+            const wrote = if (data.sparse_block)
+                try wrt.splatByte(0, to_read)
+            else
+                try wrt.write(rdr.buffer[rdr.seek .. rdr.seek + to_read]);
+            rdr.seek += wrote;
+            return wrote;
+        },
+    }
+}
+fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
+    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    if (rdr.seek == rdr.end)
+        data.advanceBuffer() catch |err| return switch (err) {
+            error.ReadFailed => error.ReadFailed,
+            error.EndOfStream => error.EndOfStream,
+            else => error.ReadFailed,
+        };
+
+    switch (limit) {
+        .nothing => return 0,
+        .unlimited => {
+            const adv = rdr.end - rdr.seek;
+            rdr.seek = rdr.end;
+            return adv;
+        },
+        else => {
+            const adv = @min(rdr.end - rdr.seek, @intFromEnum(limit));
+            rdr.seek += adv;
+            return adv;
+        },
+    }
+}
+fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
+    var data: *DataReader = @fieldParentPtr("interface", rdr);
+    if (rdr.seek == rdr.end)
+        data.advanceBuffer() catch |err| return switch (err) {
+            error.ReadFailed => error.ReadFailed,
+            error.EndOfStream => error.EndOfStream,
+            else => error.ReadFailed,
+        };
+
+    var wrote: usize = 0;
+    for (vec) |buf| {
+        if (rdr.seek == rdr.end) break;
+
+        const to_copy = @min(rdr.end - rdr.seek, buf.len);
+        if (data.sparse_block)
+            @memset(buf[0..to_copy], 0)
+        else
+            @memcpy(buf[0..to_copy], rdr.buffer[rdr.seek .. rdr.seek + to_copy]);
+        rdr.seek += to_copy;
+        wrote += to_copy;
+    }
+    return wrote;
+}

src/util/decompressor.zig

@@ -0,0 +1,15 @@
+//! A decompression interface
+
+const std = @import("std");
+
+const Decompressor = @This();
+
+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,
+
+pub fn Decompress(self: *const Decompressor, alloc: std.mem.Allocator, in: []u8, out: []u8) Error!usize {
+    return self.decomp_fn(self, alloc, in, out);
+}

src/util/metadata.zig

@@ -0,0 +1,103 @@
+const std = @import("std");
+const Reader = std.Io.Reader;
+const Writer = std.Io.Writer;
+const Limit = std.Io.Limit;
+const StreamError = std.Io.Reader.StreamError;
+
+const Decompressor = @import("decompressor.zig");
+
+const BlockHeader = packed struct(u16) {
+    size: u15,
+    uncompressed: bool,
+};
+
+const This = @This();
+
+alloc: std.mem.Allocator,
+rdr: *Reader,
+decomp: *const Decompressor,
+
+cur_block_start: u32 = 0,
+next_start_start: u32 = 0,
+buf: [8192]u8 = undefined,
+
+err: ?anyerror = null,
+interface: Reader = .{
+    .buffer = &[0]u8{},
+    .end = 0,
+    .seek = 0,
+    .vtable = &.{
+        .stream = stream,
+        .discard = discard,
+        .readVec = readVec,
+        // TODO: Potentially add rebase so that we can guarentee that self.block_start & interface.seek is correct.
+    },
+},
+
+pub fn init(alloc: std.mem.Allocator, rdr: *Reader, decomp: *const Decompressor) This {
+    return .{
+        .alloc = alloc,
+        .rdr = rdr,
+        .decomp = decomp,
+    };
+}
+
+fn advance(self: *This) !void {
+    self.interface.seek = 0;
+    var hdr: BlockHeader = undefined;
+    try self.rdr.readSliceEndian(BlockHeader, @ptrCast(&hdr), .little);
+    self.cur_block_start = self.next_start_start;
+    self.next_start_start += hdr.size;
+    if (hdr.uncompressed) {
+        try self.rdr.readSliceEndian(u8, self.buf[0..hdr.size], .little);
+        self.interface.end = hdr.size;
+        self.interface.buffer = self.buf[0..hdr.size];
+        return;
+    } else {
+        @branchHint(.likely);
+        var tmp_buf: [8192]u8 = undefined;
+        try self.rdr.readSliceAll(tmp_buf[0..hdr.size]);
+        self.interface.end = try self.decomp.Decompress(self.alloc, tmp_buf[0..hdr.size], &self.buf);
+        self.interface.buffer = self.buf[0..self.interface.end];
+    }
+}
+
+fn stream(rdr: *Reader, wrt: *Writer, limit: Limit) StreamError!usize {
+    const self: *This = @fieldParentPtr("interface", rdr);
+    if (rdr.end == rdr.seek) self.advance() catch |err| {
+        self.err = err;
+        return StreamError.ReadFailed;
+    };
+    if (@intFromEnum(limit) == 0) return 0;
+    const to_write = @min(rdr.end - rdr.seek, @intFromEnum(limit));
+    const wrote = try wrt.write(self.buf[rdr.seek .. rdr.seek + to_write]);
+    self.interface.seek += wrote;
+    return wrote;
+}
+fn discard(rdr: *Reader, limit: Limit) Reader.Error!usize {
+    const self: *This = @fieldParentPtr("interface", rdr);
+    if (rdr.end == rdr.seek) self.advance() catch |err| {
+        self.err = err;
+        return error.ReadFailed;
+    };
+    if (@intFromEnum(limit) == 0) return 0;
+    const to_skip = @min(rdr.end - rdr.seek, @intFromEnum(limit));
+    rdr.seek += to_skip;
+    return to_skip;
+}
+fn readVec(rdr: *Reader, vec: [][]u8) Reader.Error!usize {
+    const self: *This = @fieldParentPtr("interface", rdr);
+    if (rdr.end == rdr.seek) self.advance() catch |err| {
+        self.err = err;
+        return error.ReadFailed;
+    };
+    var cur_red: usize = 0;
+    for (vec) |s| {
+        const to_copy: usize = @min(rdr.end - rdr.seek, s.len);
+        @memcpy(s[0..to_copy], self.buf[rdr.seek .. rdr.seek + to_copy]);
+        rdr.seek += to_copy;
+        cur_red += to_copy;
+        if (rdr.end == rdr.seek) break;
+    }
+    return cur_red;
+}

src/util/misc.zig

@@ -0,0 +1,25 @@
+//! Miscellaneous utility functions.
+
+const std = @import("std");
+const Io = std.Io;
+
+const Inode = @import("../inode.zig");
+const Decompressor = @import("decompressor.zig");
+const MetadataReader = @import("metadata.zig");
+const OffsetFile = @import("offset_file.zig");
+
+/// check is the path is referencing itself ("" or ".").
+/// separators must be trimmed before calling this function for it to work properly.
+pub fn pathIsSelf(path: []const u8) bool {
+    if (path.len == 0) return true;
+    if (path.len > 1) return false;
+    return path[0] == '.';
+}
+/// Creates an Inode from an Inode.Ref.
+pub fn inodeFromRef(alloc: std.mem.Allocator, file: OffsetFile, decomp: *const Decompressor, inode_start: u64, block_size: u32, ref: Inode.Ref) !Inode {
+    var rdr = file.readerAt(inode_start + ref.block_start);
+    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

@@ -0,0 +1,27 @@
+//! A File where it's meaningful (to us) content starts at a given offset.
+
+const std = @import("std");
+const Io = std.Io;
+const File = Io.File;
+const Reader = Io.Reader;
+
+const OffsetFile = @This();
+
+map: Io.File.MemoryMap,
+
+pub fn init(io: Io, fil: File, archive_size: u64, init_offset: u64) !OffsetFile {
+    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, offset: u64) Reader {
+    return .fixed(self.map.memory[offset..]);
+}

src/util/shared_cache.zig

@@ -0,0 +1,52 @@
+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/utils/data_reader.zig

@@ -1,141 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Decomp = @import("../decomp.zig");
-const BlockSize = @import("../inode.zig").BlockSize;
-
-const DataReader = @This();
-
-alloc: std.mem.Allocator,
-
-data: []u8,
-decomp: Decomp.Fn,
-block_size: u32,
-
-size: u64,
-blocks: []BlockSize,
-
-frag: ?[]u8 = null,
-
-idx: u32 = 0,
-buf: []u8,
-
-interface: Io.Reader = .{
-    .buffer = &[0]u8{},
-    .seek = 0,
-    .end = 0,
-    .vtable = &.{
-        .stream = stream,
-        .discard = discard,
-        .readVec = readVec,
-    },
-},
-
-pub fn init(alloc: std.mem.Allocator, data: []u8, decomp: Decomp.Fn, block_size: u32, size: u64, blocks: []BlockSize) !DataReader {
-    return .{
-        .alloc = alloc,
-
-        .data = data,
-        .decomp = decomp,
-        .block_size = block_size,
-
-        .size = size,
-        .blocks = blocks,
-        .buf = if (blocks.len > 0) try alloc.alloc(u8, 1024 * 1024) else &[0]u8{},
-    };
-}
-pub fn deinit(self: DataReader) void {
-    self.alloc.free(self.buf);
-}
-
-pub fn addFrag(self: *DataReader, frag: []u8) void {
-    self.frag = frag;
-}
-
-fn advance(self: *DataReader) Io.Reader.Error!void {
-    if (self.idx > self.blocks.len) return error.EndOfStream;
-    defer self.idx += 1;
-
-    self.interface.seek = 0;
-    errdefer self.interface.end = 0;
-
-    if (self.idx == self.blocks.len) {
-        if (self.frag == null) return error.EndOfStream;
-
-        self.interface.buffer = self.frag.?;
-        self.interface.end = self.frag.?.len;
-        return;
-    }
-
-    self.interface.end = if (self.frag == null and self.idx == self.blocks.len - 1)
-        self.size % self.block_size
-    else
-        self.block_size;
-
-    const block = self.blocks[self.idx];
-
-    if (block.size == 0) {
-        @memset(self.buf[0..self.interface.end], 0);
-        self.interface.buffer = self.buf;
-        return;
-    }
-
-    if (block.uncompressed) {
-        self.interface.buffer = self.data;
-        self.data = self.data[self.interface.end..];
-        return;
-    }
-
-    _ = self.decomp(self.alloc, self.data[0..block.size], self.buf[0..self.interface.end]) catch return error.ReadFailed;
-    self.data = self.data[block.size..];
-
-    self.interface.buffer = self.buf;
-    return;
-}
-
-fn stream(rdr: *Io.Reader, wrt: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *DataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-    if (limit == .nothing) return 0;
-
-    const size = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-
-    const wrote = try wrt.write(rdr.buffer[rdr.seek..][0..size]);
-    rdr.seek += wrote;
-
-    return wrote;
-}
-fn discard(rdr: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *DataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-    if (limit == .nothing) return 0;
-
-    const size = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-    rdr.seek += size;
-
-    return size;
-}
-fn readVec(rdr: *Io.Reader, vec: [][]u8) Io.Reader.Error!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *DataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-
-    var wrote: usize = 0;
-    for (vec) |s| {
-        const size = @min(rdr.end - rdr.seek, s.len);
-
-        @memcpy(s[0..size], rdr.buffer[rdr.seek..][0..size]);
-
-        wrote += size;
-        rdr.seek += size;
-
-        if (rdr.seek >= rdr.end) break;
-    }
-
-    return wrote;
-}

src/utils/decompress.zig

@@ -1,219 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const Super = @import("../archive.zig").Super;
-const Decomp = @import("../decomp.zig");
-const Directory = @import("../dir.zig");
-const FragCache = @import("../frag_cache.zig");
-const Inode = @import("../inode.zig");
-const Lookup = @import("../lookup.zig");
-const Options = @import("../options.zig");
-const DataReader = @import("data_reader.zig");
-const MetadataReader = @import("meta.zig");
-
-// TODO: Add verbose logging.
-
-pub fn single(alloc: std.mem.Allocator, io: Io, data: []u8, super: Super, inode: Inode, filepath: []const u8, options: Options) !void {
-    const path = std.mem.trim(u8, filepath, "/");
-
-    var id_table: Lookup.Table(u16) = try .init(data, super.decomp_fn, super.id_table_start, super.id_count);
-    defer id_table.deinit(alloc);
-    var xattr_table: Lookup.Xattr = try .init(data, super.decomp_fn, super.xattr_table_start);
-    defer xattr_table.deinit(alloc);
-    var frag_cache: FragCache = try .init(data, super.decomp_fn, super.block_size, super.frag_table_start, super.frag_count);
-    defer frag_cache.deinit(alloc);
-
-    var pool: std.ArrayList(InodeAndPath) = try .initCapacity(alloc, 15);
-    pool.appendAssumeCapacity(.{
-        .inode = inode,
-        .path = path,
-        .root = true,
-    });
-    defer {
-        while (pool.pop()) |in|
-            in.deinit(alloc);
-        pool.deinit(alloc);
-    }
-
-    var dirs: std.ArrayList(InodeAndPath) = .empty;
-    defer {
-        while (dirs.pop()) |dir|
-            alloc.free(dir.path);
-        dirs.deinit(alloc);
-    }
-
-    var cwd = Io.Dir.cwd();
-
-    while (pool.pop()) |in| {
-        switch (in.inode.data) {
-            .dir => |d| {
-                try cwd.createDirPath(io, in.path);
-
-                if (d.size <= 3) {
-                    defer if (in.path.len != path.len)
-                        in.deinit(alloc);
-
-                    var fil = try cwd.openFile(io, in.path, .{});
-                    defer fil.close(io);
-
-                    try applyPermissions(alloc, io, &id_table, &xattr_table, in.inode.header, d.xattr_idx, fil, options);
-                    continue;
-                }
-
-                var meta: MetadataReader = .init(alloc, data[d.start..], super.decomp_fn);
-                try meta.interface.discardAll(d.offset);
-
-                var dir: Directory = try .read(alloc, &meta.interface, d.size);
-                defer dir.deinit(alloc);
-
-                for (dir.entries) |entry| {
-                    const new_inode: Inode = try .readLocation(alloc, data, entry.start, entry.offset, super);
-
-                    const new_path = std.mem.concat(alloc, u8, &.{ in.path, "/", entry.name }) catch |err| {
-                        new_inode.deinit(alloc);
-                        return err;
-                    };
-
-                    try pool.append(alloc, .{
-                        .inode = new_inode,
-                        .path = new_path,
-                        .root = false,
-                    });
-                }
-
-                try dirs.append(alloc, in);
-            },
-            .file => |f| {
-                defer if (in.path.len != path.len)
-                    in.deinit(alloc);
-
-                var atomic = try cwd.createFileAtomic(io, in.path, .{});
-                defer atomic.deinit(io);
-
-                var rdr: DataReader = try .init(alloc, data[f.start..], super.decomp_fn, super.block_size, f.size, f.blocks);
-                defer rdr.deinit();
-
-                if (f.frag_idx != 0xFFFFFFFF) {
-                    const frag = try frag_cache.get(alloc, io, f.frag_idx);
-                    rdr.addFrag(frag);
-                }
-                var buf: [1024 * 50]u8 = undefined; // TODO: find a resonable buffer size.
-                var writer = atomic.file.writer(io, &buf);
-                _ = try rdr.interface.streamRemaining(&writer.interface);
-
-                try applyPermissions(alloc, io, &id_table, &xattr_table, in.inode.header, f.xattr_idx, atomic.file, options);
-
-                try atomic.link(io);
-            },
-            .symlink => |s| {
-                defer if (in.path.len != path.len)
-                    in.deinit(alloc);
-
-                try cwd.symLink(io, s.target, in.path, .{});
-            },
-            .dev => |d| {
-                defer if (in.path.len != path.len)
-                    in.deinit(alloc);
-
-                const mode: u32 = switch (in.inode.header.type) {
-                    .char_dev, .ext_char_dev => std.os.linux.DT.CHR,
-                    .block_dev, .ext_block_dev => std.os.linux.DT.BLK,
-                    else => unreachable,
-                };
-
-                const sent_path = try alloc.dupeSentinel(u8, in.path, 0);
-
-                const res = std.os.linux.mknod(sent_path, mode, d.device);
-                alloc.free(sent_path);
-                if (res != 0)
-                    return error.MkNodError;
-
-                var fil = try cwd.openFile(io, in.path, .{});
-                defer fil.close(io);
-
-                try applyPermissions(alloc, io, &id_table, &xattr_table, in.inode.header, d.xattr_idx, fil, options);
-            },
-            .fifo => |f| {
-                defer if (in.path.len != path.len)
-                    in.deinit(alloc);
-
-                const mode: u32 = switch (in.inode.header.type) {
-                    .fifo, .ext_fifo => std.os.linux.DT.FIFO,
-                    .socket, .ext_socket => std.os.linux.DT.SOCK,
-                    else => unreachable,
-                };
-
-                const sent_path = try alloc.dupeSentinel(u8, in.path, 0);
-
-                const res = std.os.linux.mknod(sent_path, mode, 0);
-                alloc.free(sent_path);
-                if (res != 0)
-                    return error.MkNodError;
-
-                var fil = try cwd.openFile(io, in.path, .{});
-                defer fil.close(io);
-
-                try applyPermissions(alloc, io, &id_table, &xattr_table, in.inode.header, f.xattr_idx, fil, options);
-            },
-        }
-    }
-
-    while (dirs.pop()) |dir| {
-        defer if (dir.path.len != path.len)
-            alloc.free(dir.path);
-
-        var fil = try cwd.openFile(io, dir.path, .{});
-        defer fil.close(io);
-
-        try applyPermissions(alloc, io, &id_table, &xattr_table, dir.inode.header, dir.inode.data.dir.xattr_idx, fil, options);
-    }
-}
-pub fn multi(alloc: std.mem.Allocator, io: Io, data: []const u8, super: Super, inode: Inode, filepath: []const u8, options: Options) !void {
-    _ = alloc;
-    _ = io;
-    _ = data;
-    _ = super;
-    _ = inode;
-    _ = filepath;
-    _ = options;
-
-    return error.TODO;
-}
-
-// Utils
-
-const InodeAndPath = struct {
-    inode: Inode,
-    path: []const u8,
-    root: bool,
-
-    fn deinit(self: InodeAndPath, alloc: std.mem.Allocator) void {
-        if (self.root) return;
-        self.inode.deinit(alloc);
-        alloc.free(self.path);
-    }
-};
-
-fn applyPermissions(alloc: std.mem.Allocator, io: Io, id_table: *Lookup.Table(u16), xattr_table: *Lookup.Xattr, header: Inode.Header, xattr_idx: ?u32, fil: Io.File, options: Options) !void {
-    if (!options.ignore_permissions) {
-        try fil.setPermissions(io, @enumFromInt(header.permission));
-
-        try fil.setTimestamps(io, .{ .modify_timestamp = .{ .new = .fromNanoseconds(@as(i96, @intCast(header.mod_time)) * std.time.ns_per_ms) } });
-
-        try fil.setOwner(io, try id_table.get(alloc, io, header.uid_idx), try id_table.get(alloc, io, header.gid_idx));
-    }
-    if (!options.ignore_xattr and xattr_idx != null) {
-        const xattrs = try xattr_table.get(alloc, io, xattr_idx.?);
-        defer {
-            for (xattrs) |kv|
-                kv.deinit(alloc);
-            alloc.free(xattrs);
-        }
-
-        for (xattrs) |kv| {
-            const res = std.os.linux.fsetxattr(fil.handle, kv.name, kv.value.ptr, kv.value.len, 0);
-            if (res != 0)
-                return error.FSetXattrError;
-        }
-    }
-}

src/utils/meta.zig

@@ -1,109 +0,0 @@
-const std = @import("std");
-const Io = std.Io;
-
-const util = @import("util.zig");
-
-const Decomp = @import("../decomp.zig");
-
-const MetadataReader = @This();
-
-alloc: std.mem.Allocator,
-
-data: []u8,
-decomp: Decomp.Fn,
-
-decomp_block: [8192]u8 = undefined,
-
-interface: Io.Reader = .{
-    .buffer = &[0]u8{},
-    .end = 0,
-    .seek = 0,
-    .vtable = &.{
-        .stream = stream,
-        .discard = discard,
-        .readVec = readVec,
-    },
-},
-
-pub fn init(alloc: std.mem.Allocator, data: []u8, decomp: Decomp.Fn) MetadataReader {
-    return .{
-        .alloc = alloc,
-
-        .data = data,
-        .decomp = decomp,
-    };
-}
-
-fn advance(self: *MetadataReader) Io.Reader.Error!void {
-    self.interface.seek = 0;
-    errdefer self.interface.end = 0;
-
-    const hdr = util.readValue(Header, self.data[0..2]);
-
-    const block = self.data[2..][0..hdr.size];
-
-    self.data = self.data[hdr.size + 2 ..];
-
-    if (hdr.uncompressed) {
-        self.interface.end = hdr.size;
-        self.interface.buffer = block;
-        return;
-    }
-
-    self.interface.end = self.decomp(self.alloc, block, &self.decomp_block) catch return error.ReadFailed;
-    self.interface.buffer = self.decomp_block[0..self.interface.end];
-}
-
-fn stream(rdr: *Io.Reader, wrt: *Io.Writer, limit: Io.Limit) Io.Reader.StreamError!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *MetadataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-    if (limit == .nothing) return 0;
-
-    const size = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-
-    const wrote = try wrt.write(rdr.buffer[rdr.seek..][0..size]);
-    rdr.seek += wrote;
-
-    return wrote;
-}
-fn discard(rdr: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *MetadataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-    if (limit == .nothing) return 0;
-
-    const size = @min(@intFromEnum(limit), rdr.end - rdr.seek);
-    rdr.seek += size;
-
-    return size;
-}
-fn readVec(rdr: *Io.Reader, vec: [][]u8) Io.Reader.Error!usize {
-    if (rdr.seek >= rdr.end) {
-        var meta: *MetadataReader = @fieldParentPtr("interface", rdr);
-        try meta.advance();
-    }
-
-    var wrote: usize = 0;
-    for (vec) |s| {
-        const size = @min(rdr.end - rdr.seek, s.len);
-
-        @memcpy(s[0..size], rdr.buffer[rdr.seek..][0..size]);
-
-        wrote += size;
-        rdr.seek += size;
-
-        if (rdr.seek >= rdr.end) break;
-    }
-
-    return wrote;
-}
-
-// Types
-
-const Header = packed struct(u16) {
-    size: u15,
-    uncompressed: bool,
-};

src/utils/util.zig

@@ -1,28 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-pub fn readValue(comptime T: type, bytes: []u8) T {
-    var res = std.mem.bytesToValue(T, bytes);
-    if (comptime builtin.cpu.arch.endian() != .little) {
-        switch (@typeInfo(T)) {
-            .@"enum" => res = std.mem.nativeToLittle(@typeInfo(T).@"enum".tag_type, res),
-            .@"struct" => |s| {
-                if (s.layout == .@"packed") {
-                    res = @bitCast(std.mem.nativeToLittle(s.backing_integer.?, @bitCast(res)));
-                } else {
-                    std.mem.byteSwapAllFields(T, &res);
-                }
-            },
-            .int => res = std.mem.nativeToLittle(T, res),
-            .array => |a| std.mem.byteSwapAllElements(a.child, res),
-            else => unreachable,
-        }
-    }
-    return res;
-}
-pub fn readValueRdr(comptime T: type, rdr: *std.Io.Reader) !T {
-    var tmp: [@sizeOf(T)]u8 = undefined;
-    try rdr.readSliceAll(&tmp);
-
-    return readValue(T, &tmp);
-}

src/xattr_table.zig

@@ -0,0 +1,292 @@
+const std = @import("std");
+const Io = std.Io;
+
+const InodeRef = @import("inode.zig").Ref;
+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 XattrCachedTable = @This();
+
+alloc: std.mem.Allocator,
+
+fil: OffsetFile,
+decomp: *const Decompressor,
+
+kv_start: u64,
+
+table: LookupTable.CachedTable(TableValue),
+value_cache: std.AutoHashMap(InodeRef, []const u8),
+value_mut: Io.RwLock = .init,
+
+pub fn init(alloc: std.mem.Allocator, fil: OffsetFile, decomp: *const Decompressor, xattr_start: u64) !XattrCachedTable {
+    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);
+
+    return .{
+        .alloc = alloc,
+
+        .fil = fil,
+        .decomp = decomp,
+
+        .kv_start = start,
+
+        .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();
+}
+
+pub fn get(self: *XattrCachedTable, alloc: std.mem.Allocator, io: Io, idx: u32) ![]XattrSemiOwned {
+    const lookup = try self.table.get(io, idx);
+
+    var rdr = self.fil.readerAt(self.kv_start + lookup.ref.block_start);
+    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| {
+        var key_entry: KeyEntry = undefined;
+        try meta.interface.readSliceEndian(KeyEntry, @ptrCast(&key_entry), .little);
+
+        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);
+                @memcpy(tmp[0..5], "user.");
+                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);
+                @memcpy(tmp[0..8], "trusted.");
+                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);
+                @memcpy(tmp[0..9], "security.");
+                tmp[tmp.len - 1] = 0;
+                break :blk @ptrCast(tmp);
+            },
+        };
+        errdefer alloc.free(key);
+
+        if (key_entry.type.out_of_line) {
+            var value: ValueOutOfLineEntry = undefined;
+            try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
+
+            out[i] = .{
+                .key = key,
+                .value = try self.valueAt(io, value.ref),
+            };
+            continue;
+        }
+        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,
+                .value = try self.valueAt(io, val_ref),
+            };
+            continue;
+        }
+
+        var val_size: u32 = undefined;
+        try meta.interface.readSliceEndian(u32, @ptrCast(&val_size), .little);
+
+        const val = try self.alloc.alloc(u8, val_size);
+        errdefer alloc.free(val);
+        try meta.interface.readSliceEndian(u8, val, .little);
+
+        try self.value_cache.put(val_ref, val);
+        out[i] = .{
+            .key = key,
+            .value = val,
+        };
+    }
+    return out;
+}
+
+fn valueAt(self: *XattrCachedTable, io: Io, ref: InodeRef) ![]const u8 {
+    try self.value_mut.lock(io);
+    defer self.value_mut.unlock(io);
+
+    if (self.value_cache.contains(ref)) return self.value_cache.get(ref).?;
+
+    var rdr = self.fil.readerAt(self.kv_start + ref.block_start);
+    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(u32, @ptrCast(&val_size), .little);
+
+    const val = try self.alloc.alloc(u8, val_size);
+    errdefer self.alloc.free(val);
+    try meta.interface.readSliceEndian(u8, val, .little);
+
+    try self.value_cache.put(ref, val);
+    return val;
+}
+
+// Types
+
+/// An Xattr return value where the reciever only owns the key value.
+pub const XattrSemiOwned = struct {
+    key: [:0]const u8,
+    value: []const u8,
+
+    pub fn deinit(self: XattrSemiOwned, alloc: std.mem.Allocator) void {
+        alloc.free(self.key);
+    }
+};
+/// An Xattr return value where the reciever owns both the key & value.
+pub const XattrOwned = struct {
+    key: [:0]const u8,
+    value: []const u8,
+
+    pub fn deinit(self: XattrSemiOwned, alloc: std.mem.Allocator) void {
+        alloc.free(self.key);
+        alloc.free(self.value);
+    }
+};
+
+const TableValue = extern struct {
+    ref: InodeRef,
+    count: u32,
+    size: u32,
+};
+
+const KeyEntry = extern struct {
+    type: XattrPrefix,
+    name_size: u16,
+};
+const ValueOutOfLineEntry = extern struct {
+    _: u32,
+    ref: InodeRef,
+};
+
+const XattrPrefix = packed struct(u16) {
+    namespace: enum(u8) {
+        user,
+        trusted,
+        security,
+
+        fn prefixSize(self: @This()) u16 {
+            return switch (self) {
+                .user => 5,
+                .trusted => 8,
+                .security => 9,
+            };
+        }
+    },
+    out_of_line: bool,
+    _: u7,
+};
+
+// Stateless
+
+pub fn statelessLookup(alloc: std.mem.Allocator, io: Io, decomp: *const Decompressor, fil: OffsetFile, table_start: u64, idx: u16) ![]XattrOwned {
+    const kv_start: u64 = std.mem.readInt(u64, @ptrCast(fil.map.memory[table_start .. table_start + 8]), .little);
+
+    const lookup = try LookupTable.lookupValue(TableValue, alloc, io, decomp, fil, table_start + 16, idx);
+
+    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);
+
+    const out = try alloc.alloc(XattrOwned, lookup.count);
+    errdefer alloc.free(out);
+
+    for (0..lookup.count) |i| {
+        const key_entry: KeyEntry = undefined;
+        try meta.interface.readSliceEndian(KeyEntry, @ptrCast(&key_entry), .little);
+
+        const key = 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.");
+                break :blk 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.");
+                break :blk 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.");
+                break :blk tmp;
+            },
+        };
+        key[key.len - 1] = 0;
+        errdefer alloc.free(key);
+
+        if (key_entry.type.out_of_line) {
+            const value: ValueOutOfLineEntry = undefined;
+            try meta.interface.readSliceEndian(ValueOutOfLineEntry, @ptrCast(&value), .little);
+
+            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);
+
+            var val_size: u32 = undefined;
+            try ool_meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
+
+            const val = try alloc.alloc(u8, val_size);
+            errdefer alloc.free(val);
+            try ool_meta.interface.readSliceEndian(u8, val, .little);
+
+            out[i] = .{
+                .key = key,
+                .value = val,
+            };
+            continue;
+        }
+
+        var val_size: u32 = undefined;
+        try meta.interface.readSliceEndian(val_size, @ptrCast(&val_size), .little);
+
+        const val = try alloc.alloc(u8, val_size);
+        errdefer alloc.free(val);
+        try meta.interface.readSliceEndian(u8, val, .little);
+
+        out[i] = .{
+            .key = key,
+            .value = val,
+        };
+    }
+    return out;
+}