Compare revisions

79cef7c0 · 69d6cc05 · b32a421b · b4df131a · 37aab3e5 · a352d7c7
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
-image: "redoxos/redox"
+image: "redoxos/redoxer"

 stages:
    - build
    - test

-before_script:
-    - rustup target add x86_64-unknown-redox --toolchain nightly
-    - rustup show      # Print version info for debugging
-
 cache:
    paths:
        - target/

-build:linux:cargo:
+build:linux:
    stage: build
    script: cargo +nightly build --verbose

-build:redox:cargo:
+build:redox:
    stage: build
-    script: 
-        - mkdir .cargo
-        - echo -e "[target.x86_64-unknown-redox]\nlinker = \"x86_64-unknown-redox-gcc\"" > .cargo/config
-        - cargo +nightly build --verbose --target x86_64-unknown-redox
+    script: redoxer build --verbose

-test:linux:cargo:
+test:linux:
    stage: test
-    dependencies: 
-        - build:linux:cargo
+    dependencies:
+        - build:linux
    script: cargo +nightly test --verbose

-# TODO: Set up a docker image with a redox vm that would allow to
-#   run things like tests under redox
+test:redox:
+    stage: test
+    dependencies:
+        - build:redox
+    script: redoxer test --verbose
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,10 +2,11 @@
 name = "redoxfs"
 description = "The Redox Filesystem"
 repository = "https://gitlab.redox-os.org/redox-os/redoxfs"
-version = "0.3.2"
+version = "0.6.9"
 license-file = "LICENSE"
 readme = "README.md"
 authors = ["Jeremy Soller <jackpot51@gmail.com>"]
+edition = "2021"

 [lib]
 name = "redoxfs"
@@ -15,18 +16,61 @@ path = "src/lib.rs"
 name = "redoxfs"
 path = "src/bin/mount.rs"
 doc = false
+required-features = ["std"]
+
+[[bin]]
+name = "redoxfs-ar"
+path = "src/bin/ar.rs"
+doc = false
+required-features = ["std"]

 [[bin]]
 name = "redoxfs-mkfs"
 path = "src/bin/mkfs.rs"
 doc = false
+required-features = ["std"]

 [dependencies]
-spin = "0.4"
-redox_syscall = "0.1"
-uuid = { version = "0.5", features = ["v4"] }
-
-[target.'cfg(unix)'.dependencies]
-fuse = "0.3"
+aes = { version = "=0.7.5", default-features = false }
+argon2 = { version = "0.4", default-features = false, features = ["alloc"] }
+base64ct = { version = "1", default-features = false }
+env_logger = { version = "0.11", optional = true }
+endian-num = "0.1"
+getrandom = { version = "0.2.5", optional = true }
 libc = "0.2"
-time = "0.1"
+log = { version = "0.4.14", default-features = false, optional = true}
+redox_syscall = { version = "0.5" }
+range-tree = { version = "0.1", optional = true }
+seahash = { version = "4.1.0", default-features = false }
+termion = { version = "4", optional = true }
+uuid = { version = "1.4", default-features = false }
+redox-path = "0.3.0"
+libredox = { version = "0.1.3", optional = true }
+redox-scheme = {  version = "0.2.1", optional = true }
+
+[features]
+default = ["std", "log"]
+force-soft = [
+    "aes/force-soft"
+]
+std = [
+    "env_logger",
+    "fuser",
+    "getrandom",
+    "libc",
+    "libredox",
+    "range-tree",
+    "termion",
+    "time",
+    "uuid/v4",
+    "redox_syscall/std",
+    "redox-scheme"
+]
+
+[target.'cfg(not(target_os = "redox"))'.dependencies]
+fuser = { version = "0.14", optional = true }
+libc = { version = "0.2", optional = true }
+time = { version = "0.3", optional = true }
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }
--- a/DESIGN.md
+++ b/DESIGN.md
-# RedoxFS Design Document
-
-## Structures
-
-### Header
-The header is the entry point for the filesystem. When mounting a disk or image, it should be scanned for a block starting with the 8-byte signature, within the first megabyte:
-```rust
-"RedoxFS\0"
-```
-
-The header stores the filesystem version, disk identifier, disk size, root block pointer, and free block pointer.
-
-```rust
-#[repr(packed)]
-pub struct Header {
-    pub signature: [u8; 8],
-    pub version: u64,
-    pub uuid: [u8; 16],
-    pub size: u64,
-    pub root: u64,
-    pub free: u64,
-}
-```
-
-The root and free block pointers point to a Node that identifies
-
-### Node
-
-```rust
-#[repr(packed)]
-pub struct Node {
-    pub name: [u8; 256],
-    pub mode: u64,
-    pub next: u64,
-    pub extents: [Extent; 15],
-}
-```
--- a/Makefile
+++ b/Makefile
+UNAME := $(shell uname)
+
+ifeq ($(UNAME),Darwin)
+	FUMOUNT=umount
+else ifeq ($(UNAME),FreeBSD)
+	FUMOUNT=sudo umount
+else
+	# Detect which version of the fusermount binary is available.
+	ifneq (, $(shell which fusermount3))
+		FUMOUNT=fusermount3 -u
+	else
+		FUMOUNT=fusermount -u
+	endif
+endif
+
 image.bin:
-	dd if=/dev/zero of=image.bin bs=1M count=1024
 	cargo build --release --bin redoxfs-mkfs
+	dd if=/dev/zero of=image.bin bs=1048576 count=1024
 	target/release/redoxfs-mkfs image.bin

 mount: image.bin FORCE
@@ -10,12 +25,12 @@ mount: image.bin FORCE

 unmount: FORCE
 	sync
-	-fusermount -u image
+	-${FUMOUNT} image
 	rm -rf image

 clean: FORCE
 	sync
-	-fusermount -u image
+	-${FUMOUNT} image
 	rm -rf image image.bin
 	cargo clean


--- a/README.md
+++ b/README.md
-# redoxfs
-The Redox Filesystem. Compatible with Redox and Linux.
+# RedoxFS
+
+This is the default filesystem of Redox OS inspired by [ZFS](https://docs.freebsd.org/en/books/handbook/zfs/) and adapted to a microkernel architecture.
+
+(It's a replacement for [TFS](https://gitlab.redox-os.org/redox-os/tfs))
+
+Current features:
+
+- Compatible with Redox and Linux (FUSE)
+- Copy-on-write
+- Data/metadata checksums
+- Transparent encryption
+- Standard Unix file attributes
+- File/directory size limit up to 193TiB (212TB)
+- File/directory quantity limit up to 4 billion per 193TiB (2^32 - 1 = 4294967295)
+- MIT licensed
+- Disk encryption fully supported by the Redox bootloader, letting it load the kernel off an encrypted partition.
+
+Being MIT licensed, RedoxFS can be bundled on GPL-licensed operating systems (Linux, for example).
+
+### How to mount a partition
+
+- Install RedoxFS
+
+```sh
+cargo install redoxfs
+```
+
+You can also build RedoxFS from this repository.
+
+- Configure your storage device to allow rootless usage
+
+If you are on Linux you need root permission to acess block devices (storage), but it's recommended to run RedoxFS as rootless.
+
+To do that you need to configure your storage device permission to your user with the following command:
+
+```sh
+sudo setfacl -m u:your-username:rw /path/to/disk
+```
+
+- Mount your RedoxFS partition
+
+```sh
+redoxfs /path/to/disk /path/to/mount
+```

-[![Travis Build Status](https://travis-ci.org/redox-os/redoxfs.svg?branch=master)](https://travis-ci.org/redox-os/redoxfs)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![crates.io](http://meritbadge.herokuapp.com/redoxfs)](https://crates.io/crates/redoxfs)
 [![docs.rs](https://docs.rs/redoxfs/badge.svg)](https://docs.rs/redoxfs)
--- a/fuzz/.gitignore
+++ b/fuzz/.gitignore
+target
+corpus
+artifacts
+coverage
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aes"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+ "opaque-debug",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "argon2"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25df3c03f1040d0069fcd3907e24e36d59f9b6fa07ba49be0eb25a794f036ba7"
+dependencies = [
+ "base64ct",
+ "blake2",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cc"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+dependencies = [
+ "jobserver",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "cipher"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "endian-num"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad847bb2094f110bbdd6fa564894ca4556fd978958e93985420d680d3cb6d14"
+
+[[package]]
+name = "env_logger"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+
+[[package]]
+name = "fuser"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5910691a0ececcc6eba8bb14029025c2d123e96a53db1533f6a4602861a5aaf7"
+dependencies = [
+ "libc",
+ "log",
+ "memchr",
+ "page_size",
+ "pkg-config",
+ "smallvec",
+ "users",
+ "zerocopy",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "jobserver"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.155"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
+[[package]]
+name = "libredox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+ "redox_syscall 0.4.1",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+ "redox_syscall 0.5.2",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.5.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "numtoa"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "page_size"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "range-tree"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384c2842d4e069d5ccacf5fe1dca4ef8d07a5444329715f0fc3c61813502d4d1"
+
+[[package]]
+name = "redox-path"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436d45c2b6a5b159d43da708e62b25be3a4a3d5550d654b72216ade4c4bfd717"
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+dependencies = [
+ "bitflags 2.5.0",
+]
+
+[[package]]
+name = "redox_termios"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
+
+[[package]]
+name = "redoxfs"
+version = "0.6.4"
+dependencies = [
+ "aes",
+ "argon2",
+ "base64ct",
+ "endian-num",
+ "env_logger",
+ "fuser",
+ "getrandom",
+ "libc",
+ "libredox 0.1.3",
+ "log",
+ "range-tree",
+ "redox-path",
+ "redox_syscall 0.5.2",
+ "seahash",
+ "termion",
+ "time",
+ "uuid",
+]
+
+[[package]]
+name = "redoxfs-fuzz"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "arbitrary",
+ "fuser",
+ "libfuzzer-sys",
+ "nix",
+ "redoxfs",
+ "tempfile",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+
+[[package]]
+name = "rustix"
+version = "0.38.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "syn"
+version = "2.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "termion"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4648c7def6f2043b2568617b9f9b75eae88ca185dbc1f1fda30e95a85d49d7d"
+dependencies = [
+ "libc",
+ "libredox 0.0.2",
+ "numtoa",
+ "redox_termios",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "users"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24cc0f6d6f267b73e5a2cadf007ba8f9bc39c6a6f9666f8cf25ea809a153b032"
+dependencies = [
+ "libc",
+ "log",
+]
+
+[[package]]
+name = "uuid"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+
+[[package]]
+name = "zerocopy"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854e949ac82d619ee9a14c66a1b674ac730422372ccb759ce0c39cabcf2bf8e6"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "125139de3f6b9d625c39e2efdd73d41bdac468ccd556556440e322be0e1bbd91"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
+[package]
+name = "redoxfs-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[features]
+default = []
+log = []
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+anyhow = "1.0.86"
+arbitrary = { version = "1.3.2", features = ["derive"] }
+fuser = { version = "0.12.0" }
+libfuzzer-sys = "0.4"
+nix = { version = "0.29.0", features = ["fs"] }
+tempfile = "3.10.1"
+
+[dependencies.redoxfs]
+path = ".."
+
+[[bin]]
+name = "fuse_fuzz_target"
+path = "fuzz_targets/fuse_fuzz_target.rs"
+test = false
+doc = false
+bench = false
--- a/fuzz/fuzz_targets/fuse_fuzz_target.rs
+++ b/fuzz/fuzz_targets/fuse_fuzz_target.rs
+//! Fuzzer that exercises random file system operations against a FUSE-mounted redoxfs.
+
+#![no_main]
+
+use anyhow::{ensure, Result};
+use fuser;
+use libfuzzer_sys::{arbitrary::Arbitrary, fuzz_target, Corpus};
+use nix::sys::statvfs::statvfs;
+use std::{
+    fs::{self, File, FileTimes, OpenOptions},
+    io::{Read, Seek, SeekFrom, Write},
+    os::unix::fs::{self as unix_fs, PermissionsExt},
+    path::{Path, PathBuf},
+    thread,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tempfile;
+
+use redoxfs::{mount::fuse::Fuse, DiskSparse, FileSystem};
+
+/// Maximum size for files and buffers. Chosen arbitrarily with fuzzing performance in mind.
+const MAX_SIZE: u64 = 10_000_000;
+/// Limit on the number of remounts in a single test case. Chosen arbitrarily with fuzzing
+/// performance in mind: remounts are costly.
+const MAX_MOUNT_SEQUENCES: usize = 3;
+
+/// An operation to be performed by the fuzzer.
+#[derive(Arbitrary, Clone, Debug)]
+enum Operation {
+    Chown {
+        path: PathBuf,
+        uid: Option<u32>,
+        gid: Option<u32>,
+    },
+    CreateDir {
+        path: PathBuf,
+    },
+    HardLink {
+        original: PathBuf,
+        link: PathBuf,
+    },
+    Metadata {
+        path: PathBuf,
+    },
+    Read {
+        path: PathBuf,
+    },
+    ReadDir {
+        path: PathBuf,
+    },
+    ReadLink {
+        path: PathBuf,
+    },
+    RemoveDir {
+        path: PathBuf,
+    },
+    RemoveFile {
+        path: PathBuf,
+    },
+    Rename {
+        from: PathBuf,
+        to: PathBuf,
+    },
+    SeekRead {
+        path: PathBuf,
+        seek_pos: u64,
+        buf_size: usize,
+    },
+    SeekWrite {
+        path: PathBuf,
+        seek_pos: u64,
+        buf_size: usize,
+    },
+    SetLen {
+        path: PathBuf,
+        size: u64,
+    },
+    SetPermissions {
+        path: PathBuf,
+        readonly: Option<bool>,
+        mode: Option<u32>,
+    },
+    SetTimes {
+        path: PathBuf,
+        accessed_since_epoch: Option<Duration>,
+        modified_since_epoch: Option<Duration>,
+    },
+    Statvfs {},
+    SymLink {
+        original: PathBuf,
+        link: PathBuf,
+    },
+    Write {
+        path: PathBuf,
+        buf_size: usize,
+    },
+}
+
+/// Parameters for mounting the file system and operations to be performed afterwards.
+#[derive(Arbitrary, Clone, Debug)]
+struct MountSequence {
+    squash: bool,
+    operations: Vec<Operation>,
+}
+
+/// The whole input to a single fuzzer invocation.
+#[derive(Arbitrary, Clone, Debug)]
+struct TestCase {
+    disk_size: u64,
+    reserved_size: u64,
+    mount_sequences: Vec<MountSequence>,
+}
+
+/// Creates the disk for backing the Redoxfs.
+fn create_disk(temp_path: &Path, disk_size: u64) -> DiskSparse {
+    let disk_path = temp_path.join("disk.img");
+    DiskSparse::create(disk_path, disk_size).unwrap()
+}
+
+/// Creates an empty Redoxfs.
+fn create_redoxfs(disk: DiskSparse, reserved_size: u64) -> bool {
+    let password = None;
+    let reserved = vec![0; reserved_size as usize];
+    let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+    FileSystem::create_reserved(
+        disk,
+        password,
+        &reserved,
+        ctime.as_secs(),
+        ctime.subsec_nanos(),
+    )
+    .is_ok()
+}
+
+/// Mounts an existing Redoxfs, runs the callback and performs the unmount.
+fn with_redoxfs_mount<F>(temp_path: &Path, disk: DiskSparse, squash: bool, callback: F)
+where
+    F: FnOnce(&Path) + Send + 'static,
+{
+    let password = None;
+    let block = None;
+    let mut fs = FileSystem::open(disk, password, block, squash).unwrap();
+
+    let mount_path = temp_path.join("mount");
+    fs::create_dir_all(&mount_path).unwrap();
+    let mut session = fuser::Session::new(Fuse { fs: &mut fs }, &mount_path, &[]).unwrap();
+    let mut unmounter = session.unmount_callable();
+
+    let join_handle = thread::spawn(move || {
+        callback(&mount_path);
+        unmounter.unmount().unwrap();
+    });
+
+    session.run().unwrap();
+    join_handle.join().unwrap();
+}
+
+fn get_path_within_fs(fs_path: &Path, path_to_add: &Path) -> Result<PathBuf> {
+    ensure!(path_to_add.is_relative());
+    ensure!(path_to_add
+        .components()
+        .all(|c| c != std::path::Component::ParentDir));
+    Ok(fs_path.join(path_to_add))
+}
+
+fn do_operation(fs_path: &Path, op: &Operation) -> Result<()> {
+    match op {
+        Operation::Chown { path, uid, gid } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            unix_fs::chown(path, *uid, *gid)?;
+        }
+        Operation::CreateDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::create_dir(path)?;
+        }
+        Operation::HardLink { original, link } => {
+            let original = get_path_within_fs(fs_path, original)?;
+            let link = get_path_within_fs(fs_path, link)?;
+            fs::hard_link(original, link)?;
+        }
+        Operation::Metadata { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::metadata(path)?;
+        }
+        Operation::Read { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::read(path)?;
+        }
+        Operation::ReadDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let _ = fs::read_dir(path)?.count();
+        }
+        Operation::ReadLink { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::read_link(path)?;
+        }
+        Operation::RemoveDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::remove_dir(path)?;
+        }
+        Operation::RemoveFile { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::remove_file(path)?;
+        }
+        Operation::Rename { from, to } => {
+            let from = get_path_within_fs(fs_path, from)?;
+            let to = get_path_within_fs(fs_path, to)?;
+            fs::rename(from, to)?;
+        }
+        Operation::SeekRead {
+            path,
+            seek_pos,
+            buf_size,
+        } => {
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let mut file = File::open(path)?;
+            file.seek(SeekFrom::Start(*seek_pos))?;
+            let mut buf = vec![0; *buf_size];
+            file.read(&mut buf)?;
+        }
+        Operation::SeekWrite {
+            path,
+            seek_pos,
+            buf_size,
+        } => {
+            ensure!(*seek_pos <= MAX_SIZE);
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let mut file = OpenOptions::new().write(true).open(path)?;
+            file.seek(SeekFrom::Start(*seek_pos))?;
+            let buf = vec![0; *buf_size];
+            file.write(&buf)?;
+        }
+        Operation::SetLen { path, size } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let file = OpenOptions::new().write(true).open(path)?;
+            file.set_len(*size)?;
+        }
+        Operation::SetPermissions {
+            path,
+            readonly,
+            mode,
+        } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let metadata = fs::metadata(&path)?;
+            let mut perms = metadata.permissions();
+            if let Some(readonly) = readonly {
+                perms.set_readonly(*readonly);
+            }
+            if let Some(mode) = mode {
+                perms.set_mode(*mode);
+            }
+            fs::set_permissions(path, perms)?;
+        }
+        Operation::SetTimes {
+            path,
+            accessed_since_epoch,
+            modified_since_epoch,
+        } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let file = File::options().write(true).open(path)?;
+            let mut times = FileTimes::new();
+            if let Some(accessed_since_epoch) = accessed_since_epoch {
+                if let Some(accessed) = UNIX_EPOCH.checked_add(*accessed_since_epoch) {
+                    times = times.set_accessed(accessed);
+                }
+            }
+            if let Some(modified_since_epoch) = modified_since_epoch {
+                if let Some(modified) = UNIX_EPOCH.checked_add(*modified_since_epoch) {
+                    times = times.set_modified(modified);
+                }
+            }
+            file.set_times(times)?;
+        }
+        Operation::Statvfs {} => {
+            statvfs(fs_path)?;
+        }
+        Operation::SymLink { original, link } => {
+            let original = get_path_within_fs(fs_path, original)?;
+            let link = get_path_within_fs(fs_path, link)?;
+            unix_fs::symlink(original, link)?;
+        }
+        Operation::Write { path, buf_size } => {
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let buf = vec![0; *buf_size];
+            fs::write(path, &buf)?;
+        }
+    }
+    Ok(())
+}
+
+fuzz_target!(|test_case: TestCase| -> Corpus {
+    if test_case.disk_size > MAX_SIZE
+        || test_case.reserved_size > MAX_SIZE
+        || test_case.mount_sequences.len() > MAX_MOUNT_SEQUENCES
+    {
+        return Corpus::Reject;
+    }
+
+    let temp_dir = tempfile::Builder::new()
+        .prefix("fuse_fuzz_target")
+        .tempdir()
+        .unwrap();
+
+    #[cfg(feature = "log")]
+    eprintln!("create fs");
+    let disk = create_disk(temp_dir.path(), test_case.disk_size);
+    if !create_redoxfs(disk, test_case.reserved_size) {
+        // File system creation failed (e.g., due to insufficient space) so we bail out, still
+        // exercising this code path is useful.
+        return Corpus::Keep;
+    }
+
+    for mount_seq in test_case.mount_sequences.iter() {
+        #[cfg(feature = "log")]
+        eprintln!("mount fs");
+
+        let disk = create_disk(temp_dir.path(), test_case.disk_size);
+        let operations = mount_seq.operations.clone();
+        with_redoxfs_mount(temp_dir.path(), disk, mount_seq.squash, move |fs_path| {
+            for operation in operations.iter() {
+                #[cfg(feature = "log")]
+                eprintln!("do operation {operation:?}");
+
+                let _result = do_operation(fs_path, operation);
+
+                #[cfg(feature = "log")]
+                eprintln!("operation result {:?}", _result.err());
+            }
+        });
+
+        #[cfg(feature = "log")]
+        eprintln!("unmounted fs");
+    }
+    Corpus::Keep
+});
--- a/src/allocator.rs
+++ b/src/allocator.rs
+use alloc::vec::Vec;
+use core::{fmt, mem, ops, slice};
+use endian_num::Le;
+
+use crate::{BlockAddr, BlockLevel, BlockPtr, BlockTrait, BLOCK_SIZE};
+
+pub const ALLOC_LIST_ENTRIES: usize =
+    (BLOCK_SIZE as usize - mem::size_of::<BlockPtr<AllocList>>()) / mem::size_of::<AllocEntry>();
+
+/// The RedoxFS block allocator. This struct manages all "data" blocks in RedoxFS
+/// (i.e, all blocks that aren't reserved or part of the header chain).
+///
+/// [`Allocator`] can allocate blocks of many "levels"---that is, it can
+/// allocate multiple consecutive [`BLOCK_SIZE`] blocks in one operation.
+///
+/// This reduces the amount of memory that the [`Allocator`] uses:
+/// Instead of storing the index of each free [`BLOCK_SIZE`] block,
+/// the `levels` array can keep track of higher-level blocks, splitting
+/// them when a smaller block is requested.
+///
+/// Higher-level blocks also allow us to more efficiently allocate memory
+/// for large files.
+#[derive(Clone, Default)]
+pub struct Allocator {
+    /// This array keeps track of all free blocks of each level,
+    /// and is initialized using the AllocList chain when we open the filesystem.
+    ///
+    /// Every element of the outer array represents a block level:
+    /// - item 0: free level 0 blocks (with size [`BLOCK_SIZE`])
+    /// - item 1: free level 1 blocks (with size 2*[`BLOCK_SIZE`])
+    /// - item 2: free level 2 blocks (with size 4*[`BLOCK_SIZE`])
+    /// ...and so on.
+    ///
+    /// Each inner array contains a list of free block indices,
+    levels: Vec<Vec<u64>>,
+}
+
+impl Allocator {
+    pub fn levels(&self) -> &Vec<Vec<u64>> {
+        &self.levels
+    }
+
+    /// Count the number of free [`BLOCK_SIZE`] available to this [`Allocator`].
+    pub fn free(&self) -> u64 {
+        let mut free = 0;
+        for level in 0..self.levels.len() {
+            let level_size = 1 << level;
+            free += self.levels[level].len() as u64 * level_size;
+        }
+        free
+    }
+
+    /// Find a free block of the given level, mark it as "used", and return its address.
+    /// Returns [`None`] if there are no free blocks with this level.
+    pub fn allocate(&mut self, block_level: BlockLevel) -> Option<BlockAddr> {
+        // First, find the lowest level with a free block
+        let mut index_opt = None;
+        let mut level = block_level.0;
+        // Start searching at the level we want. Smaller levels are too small!
+        while level < self.levels.len() {
+            if !self.levels[level].is_empty() {
+                index_opt = self.levels[level].pop();
+                break;
+            }
+            level += 1;
+        }
+
+        // If a free block was found, split it until we find a usable block of the right level.
+        // The left side of the split block is kept free, and the right side is allocated.
+        let index = index_opt?;
+        while level > block_level.0 {
+            level -= 1;
+            let level_size = 1 << level;
+            self.levels[level].push(index + level_size);
+        }
+
+        Some(unsafe { BlockAddr::new(index, block_level) })
+    }
+
+    /// Try to allocate the exact block specified, making all necessary splits.
+    /// Returns [`None`] if this some (or all) of this block is already allocated.
+    ///
+    /// Note that [`BlockAddr`] encodes the blocks location _and_ level.
+    pub fn allocate_exact(&mut self, exact_addr: BlockAddr) -> Option<BlockAddr> {
+        // This function only supports level 0 right now
+        assert_eq!(exact_addr.level().0, 0);
+        let exact_index = exact_addr.index();
+
+        let mut index_opt = None;
+
+        // Go from the highest to the lowest level
+        for level in (0..self.levels.len()).rev() {
+            let level_size = 1 << level;
+
+            // Split higher block if found
+            if let Some(index) = index_opt.take() {
+                self.levels[level].push(index);
+                self.levels[level].push(index + level_size);
+            }
+
+            // Look for matching block and remove it
+            for i in 0..self.levels[level].len() {
+                let start = self.levels[level][i];
+                if start <= exact_index {
+                    let end = start + level_size;
+                    if end > exact_index {
+                        self.levels[level].remove(i);
+                        index_opt = Some(start);
+                        break;
+                    }
+                }
+            }
+        }
+
+        Some(unsafe { BlockAddr::new(index_opt?, exact_addr.level()) })
+    }
+
+    /// Deallocate the given block, marking it "free" so that it can be re-used later.
+    pub fn deallocate(&mut self, addr: BlockAddr) {
+        // When we deallocate, we check if block we're deallocating has a free sibling.
+        // If it does, we join the two to create one free block in the next (higher) level.
+        //
+        // We repeat this until we no longer have a sibling to join.
+        let mut index = addr.index();
+        let mut level = addr.level().0;
+        loop {
+            while level >= self.levels.len() {
+                self.levels.push(Vec::new());
+            }
+
+            let level_size = 1 << level;
+            let next_size = level_size << 1;
+
+            let mut found = false;
+            let mut i = 0;
+            // look at all free blocks in the current level...
+            while i < self.levels[level].len() {
+                // index of the second block we're looking at
+                let level_index = self.levels[level][i];
+
+                // - the block we just freed aligns with the next largest block, and
+                // - the second block we're looking at is the right sibling of this block
+                if index % next_size == 0 && index + level_size == level_index {
+                    // "alloc" the next highest block, repeat deallocation process.
+                    self.levels[level].remove(i);
+                    found = true;
+                    break;
+                // - the index of this block doesn't align with the next largest block, and
+                // - the block we're looking at is the left neighbor of this block
+                } else if level_index % next_size == 0 && level_index + level_size == index {
+                    // "alloc" the next highest block, repeat deallocation process.
+                    self.levels[level].remove(i);
+                    index = level_index; // index moves to left block
+                    found = true;
+                    break;
+                }
+                i += 1;
+            }
+
+            // We couldn't find a higher block,
+            // deallocate this one and finish
+            if !found {
+                self.levels[level].push(index);
+                return;
+            }
+
+            // repeat deallocation process on the
+            // higher-level block we just created.
+            level += 1;
+        }
+    }
+}
+
+#[repr(C, packed)]
+pub struct AllocEntry {
+    /// The index of the first block this [`AllocEntry`] refers to
+    index: Le<u64>,
+
+    /// The number of blocks after (and including) `index` that are are free or used.
+    /// If negative, they are used; if positive, they are free.
+    count: Le<i64>,
+}
+
+impl AllocEntry {
+    pub fn new(index: u64, count: i64) -> Self {
+        Self {
+            index: index.into(),
+            count: count.into(),
+        }
+    }
+
+    pub fn allocate(addr: BlockAddr) -> Self {
+        Self::new(addr.index(), -addr.level().blocks())
+    }
+
+    pub fn deallocate(addr: BlockAddr) -> Self {
+        Self::new(addr.index(), addr.level().blocks())
+    }
+
+    pub fn index(&self) -> u64 {
+        self.index.to_ne()
+    }
+
+    pub fn count(&self) -> i64 {
+        self.count.to_ne()
+    }
+
+    pub fn is_null(&self) -> bool {
+        self.count() == 0
+    }
+}
+
+impl Clone for AllocEntry {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for AllocEntry {}
+
+impl Default for AllocEntry {
+    fn default() -> Self {
+        Self {
+            index: 0.into(),
+            count: 0.into(),
+        }
+    }
+}
+
+impl fmt::Debug for AllocEntry {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let index = self.index();
+        let count = self.count();
+        f.debug_struct("AllocEntry")
+            .field("index", &index)
+            .field("count", &count)
+            .finish()
+    }
+}
+
+/// A node in the allocation chain.
+#[repr(C, packed)]
+pub struct AllocList {
+    /// A pointer to the previous AllocList.
+    /// If this is the null pointer, this is the first element of the chain.
+    pub prev: BlockPtr<AllocList>,
+
+    /// Allocation entries.
+    pub entries: [AllocEntry; ALLOC_LIST_ENTRIES],
+}
+
+unsafe impl BlockTrait for AllocList {
+    fn empty(level: BlockLevel) -> Option<Self> {
+        if level.0 == 0 {
+            Some(Self {
+                prev: BlockPtr::default(),
+                entries: [AllocEntry::default(); ALLOC_LIST_ENTRIES],
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl fmt::Debug for AllocList {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let prev = self.prev;
+        let entries: Vec<&AllocEntry> = self
+            .entries
+            .iter()
+            .filter(|entry| entry.count() > 0)
+            .collect();
+        f.debug_struct("AllocList")
+            .field("prev", &prev)
+            .field("entries", &entries)
+            .finish()
+    }
+}
+
+impl ops::Deref for AllocList {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        unsafe {
+            slice::from_raw_parts(
+                self as *const AllocList as *const u8,
+                mem::size_of::<AllocList>(),
+            ) as &[u8]
+        }
+    }
+}
+
+impl ops::DerefMut for AllocList {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        unsafe {
+            slice::from_raw_parts_mut(
+                self as *mut AllocList as *mut u8,
+                mem::size_of::<AllocList>(),
+            ) as &mut [u8]
+        }
+    }
+}
+
+#[test]
+fn alloc_node_size_test() {
+    assert_eq!(mem::size_of::<AllocList>(), crate::BLOCK_SIZE as usize);
+}
+
+#[test]
+fn allocator_test() {
+    let mut alloc = Allocator::default();
+
+    assert_eq!(alloc.allocate(BlockLevel::default()), None);
+
+    alloc.deallocate(unsafe { BlockAddr::new(1, BlockLevel::default()) });
+    assert_eq!(
+        alloc.allocate(BlockLevel::default()),
+        Some(unsafe { BlockAddr::new(1, BlockLevel::default()) })
+    );
+    assert_eq!(alloc.allocate(BlockLevel::default()), None);
+
+    for addr in 1023..2048 {
+        alloc.deallocate(unsafe { BlockAddr::new(addr, BlockLevel::default()) });
+    }
+
+    assert_eq!(alloc.levels.len(), 11);
+    for level in 0..alloc.levels.len() {
+        if level == 0 {
+            assert_eq!(alloc.levels[level], [1023]);
+        } else if level == 10 {
+            assert_eq!(alloc.levels[level], [1024]);
+        } else {
+            assert_eq!(alloc.levels[level], []);
+        }
+    }
+
+    for addr in 1023..2048 {
+        assert_eq!(
+            alloc.allocate(BlockLevel::default()),
+            Some(unsafe { BlockAddr::new(addr, BlockLevel::default()) })
+        );
+    }
+    assert_eq!(alloc.allocate(BlockLevel::default()), None);
+
+    assert_eq!(alloc.levels.len(), 11);
+    for level in 0..alloc.levels.len() {
+        assert_eq!(alloc.levels[level], []);
+    }
+}
--- a/src/archive.rs
+++ b/src/archive.rs
+use std::fs;
+use std::io;
+use std::os::unix::ffi::OsStrExt;
+use std::os::unix::fs::MetadataExt;
+use std::path::Path;
+
+use crate::{Disk, FileSystem, Node, Transaction, TreePtr, BLOCK_SIZE};
+
+fn syscall_err(err: syscall::Error) -> io::Error {
+    io::Error::from_raw_os_error(err.errno)
+}
+
+pub fn archive_at<D: Disk, P: AsRef<Path>>(
+    tx: &mut Transaction<D>,
+    parent_path: P,
+    parent_ptr: TreePtr<Node>,
+) -> io::Result<()> {
+    for entry_res in fs::read_dir(parent_path)? {
+        let entry = entry_res?;
+
+        let metadata = entry.metadata()?;
+        let file_type = metadata.file_type();
+
+        let name = entry.file_name().into_string().map_err(|_| {
+            io::Error::new(io::ErrorKind::InvalidData, "filename is not valid UTF-8")
+        })?;
+
+        let mode_type = if file_type.is_dir() {
+            Node::MODE_DIR
+        } else if file_type.is_file() {
+            Node::MODE_FILE
+        } else if file_type.is_symlink() {
+            Node::MODE_SYMLINK
+        } else {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("Does not support parsing {:?}", file_type),
+            ));
+        };
+
+        let node_ptr;
+        {
+            let mode = mode_type | (metadata.mode() as u16 & Node::MODE_PERM);
+            let mut node = tx
+                .create_node(
+                    parent_ptr,
+                    &name,
+                    mode,
+                    metadata.ctime() as u64,
+                    metadata.ctime_nsec() as u32,
+                )
+                .map_err(syscall_err)?;
+
+            node_ptr = node.ptr();
+
+            if node.data().uid() != metadata.uid() || node.data().gid() != metadata.gid() {
+                node.data_mut().set_uid(metadata.uid());
+                node.data_mut().set_gid(metadata.gid());
+                tx.sync_tree(node).map_err(syscall_err)?;
+            }
+        }
+
+        let path = entry.path();
+        if file_type.is_dir() {
+            archive_at(tx, path, node_ptr)?;
+        } else if file_type.is_file() {
+            let data = fs::read(path)?;
+            let count = tx
+                .write_node(
+                    node_ptr,
+                    0,
+                    &data,
+                    metadata.mtime() as u64,
+                    metadata.mtime_nsec() as u32,
+                )
+                .map_err(syscall_err)?;
+            if count != data.len() {
+                panic!("file write count {} != {}", count, data.len());
+            }
+        } else if file_type.is_symlink() {
+            let destination = fs::read_link(path)?;
+            let data = destination.as_os_str().as_bytes();
+            let count = tx
+                .write_node(
+                    node_ptr,
+                    0,
+                    data,
+                    metadata.mtime() as u64,
+                    metadata.mtime_nsec() as u32,
+                )
+                .map_err(syscall_err)?;
+            if count != data.len() {
+                panic!("symlink write count {} != {}", count, data.len());
+            }
+        } else {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("Does not support creating {:?}", file_type),
+            ));
+        }
+    }
+
+    Ok(())
+}
+
+pub fn archive<D: Disk, P: AsRef<Path>>(fs: &mut FileSystem<D>, parent_path: P) -> io::Result<u64> {
+    let end_block = fs
+        .tx(|tx| {
+            // Archive_at root node
+            archive_at(tx, parent_path, TreePtr::root())
+                .map_err(|err| syscall::Error::new(err.raw_os_error().unwrap()))?;
+
+            // Squash alloc log
+            tx.sync(true)?;
+
+            let end_block = tx.header.size() / BLOCK_SIZE;
+            /* TODO: Cut off any free blocks at the end of the filesystem
+            let mut end_changed = true;
+            while end_changed {
+                end_changed = false;
+
+                let allocator = fs.allocator();
+                let levels = allocator.levels();
+                for level in 0..levels.len() {
+                    let level_size = 1 << level;
+                    for &block in levels[level].iter() {
+                        if block < end_block && block + level_size >= end_block {
+                            end_block = block;
+                            end_changed = true;
+                        }
+                    }
+                }
+            }
+            */
+
+            // Update header
+            tx.header.size = (end_block * BLOCK_SIZE).into();
+            tx.header_changed = true;
+            tx.sync(false)?;
+
+            Ok(end_block)
+        })
+        .map_err(syscall_err)?;
+
+    Ok((fs.block + end_block) * BLOCK_SIZE)
+}
--- a/src/bin/ar.rs
+++ b/src/bin/ar.rs
+extern crate redoxfs;
+extern crate syscall;
+extern crate uuid;
+
+use std::io::Read;
+use std::time::{SystemTime, UNIX_EPOCH};
+use std::{env, fs, process};
+
+use redoxfs::{archive, DiskFile, FileSystem};
+use uuid::Uuid;
+
+fn main() {
+    env_logger::init();
+
+    let mut args = env::args().skip(1);
+
+    let disk_path = if let Some(path) = args.next() {
+        path
+    } else {
+        println!("redoxfs-ar: no disk image provided");
+        println!("redoxfs-ar DISK FOLDER [BOOTLOADER]");
+        process::exit(1);
+    };
+
+    let folder_path = if let Some(path) = args.next() {
+        path
+    } else {
+        println!("redoxfs-ar: no folder provided");
+        println!("redoxfs-ar DISK FOLDER [BOOTLOADER]");
+        process::exit(1);
+    };
+
+    let bootloader_path_opt = args.next();
+
+    let disk = match DiskFile::open(&disk_path) {
+        Ok(disk) => disk,
+        Err(err) => {
+            println!("redoxfs-ar: failed to open image {}: {}", disk_path, err);
+            process::exit(1);
+        }
+    };
+
+    let mut bootloader = vec![];
+    if let Some(bootloader_path) = bootloader_path_opt {
+        match fs::File::open(&bootloader_path) {
+            Ok(mut file) => match file.read_to_end(&mut bootloader) {
+                Ok(_) => (),
+                Err(err) => {
+                    println!(
+                        "redoxfs-ar: failed to read bootloader {}: {}",
+                        bootloader_path, err
+                    );
+                    process::exit(1);
+                }
+            },
+            Err(err) => {
+                println!(
+                    "redoxfs-ar: failed to open bootloader {}: {}",
+                    bootloader_path, err
+                );
+                process::exit(1);
+            }
+        }
+    };
+
+    let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+    match FileSystem::create_reserved(
+        disk,
+        None,
+        &bootloader,
+        ctime.as_secs(),
+        ctime.subsec_nanos(),
+    ) {
+        Ok(mut fs) => {
+            let size = match archive(&mut fs, &folder_path) {
+                Ok(ok) => ok,
+                Err(err) => {
+                    println!("redoxfs-ar: failed to archive {}: {}", folder_path, err);
+                    process::exit(1);
+                }
+            };
+
+            if let Err(err) = fs.disk.file.set_len(size) {
+                println!(
+                    "redoxfs-ar: failed to truncate {} to {}: {}",
+                    disk_path, size, err
+                );
+                process::exit(1);
+            }
+
+            let uuid = Uuid::from_bytes(fs.header.uuid());
+            println!(
+                "redoxfs-ar: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}",
+                disk_path,
+                fs.block,
+                fs.header.size() / 1000 / 1000,
+                uuid.hyphenated()
+            );
+        }
+        Err(err) => {
+            println!(
+                "redoxfs-ar: failed to create filesystem on {}: {}",
+                disk_path, err
+            );
+            process::exit(1);
+        }
+    };
+}
--- a/src/bin/mkfs.rs
+++ b/src/bin/mkfs.rs
-#![deny(warnings)]
-
 extern crate redoxfs;
 extern crate uuid;

-use std::{env, fs, process, time};
 use std::io::Read;
+use std::{env, fs, io, process, time};

-use redoxfs::{FileSystem, DiskFile};
+use redoxfs::{DiskFile, FileSystem};
+use termion::input::TermRead;
 use uuid::Uuid;

+fn usage() -> ! {
+    eprintln!("redoxfs-mkfs [--encrypt] DISK [BOOTLOADER]");
+    process::exit(1);
+}
+
 fn main() {
-    let mut args = env::args().skip(1);
+    env_logger::init();

-    let disk_path = if let Some(path) = args.next() {
+    let mut encrypt = false;
+    let mut disk_path_opt = None;
+    let mut bootloader_path_opt = None;
+    for arg in env::args().skip(1) {
+        if arg == "--encrypt" {
+            encrypt = true;
+        } else if disk_path_opt.is_none() {
+            disk_path_opt = Some(arg);
+        } else if bootloader_path_opt.is_none() {
+            bootloader_path_opt = Some(arg);
+        } else {
+            eprintln!("redoxfs-mkfs: too many arguments provided");
+            usage();
+        }
+    }
+
+    let disk_path = if let Some(path) = disk_path_opt {
        path
    } else {
-        println!("redoxfs-mkfs: no disk image provided");
-        println!("redoxfs-mkfs DISK [BOOTLOADER]");
-        process::exit(1);
+        eprintln!("redoxfs-mkfs: no disk image provided");
+        usage();
    };

-    let bootloader_path_opt = args.next();
-
    let disk = match DiskFile::open(&disk_path) {
        Ok(disk) => disk,
        Err(err) => {
-            println!("redoxfs-mkfs: failed to open image {}: {}", disk_path, err);
+            eprintln!("redoxfs-mkfs: failed to open image {}: {}", disk_path, err);
            process::exit(1);
        }
    };
@@ -36,25 +53,68 @@ fn main() {
            Ok(mut file) => match file.read_to_end(&mut bootloader) {
                Ok(_) => (),
                Err(err) => {
-                    println!("redoxfs-mkfs: failed to read bootloader {}: {}", bootloader_path, err);
+                    eprintln!(
+                        "redoxfs-mkfs: failed to read bootloader {}: {}",
+                        bootloader_path, err
+                    );
                    process::exit(1);
                }
            },
            Err(err) => {
-                println!("redoxfs-mkfs: failed to open bootloader {}: {}", bootloader_path, err);
+                eprintln!(
+                    "redoxfs-mkfs: failed to open bootloader {}: {}",
+                    bootloader_path, err
+                );
                process::exit(1);
            }
        }
    };

-    let ctime = time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap();
-    match FileSystem::create_reserved(disk, &bootloader, ctime.as_secs(), ctime.subsec_nanos()) {
+    let password_opt = if encrypt {
+        eprint!("redoxfs-mkfs: password: ");
+
+        let password = io::stdin()
+            .read_passwd(&mut io::stderr())
+            .unwrap()
+            .unwrap_or_default();
+
+        eprintln!();
+
+        if password.is_empty() {
+            eprintln!("redoxfs-mkfs: empty password, giving up");
+            process::exit(1);
+        }
+
+        Some(password)
+    } else {
+        None
+    };
+
+    let ctime = time::SystemTime::now()
+        .duration_since(time::UNIX_EPOCH)
+        .unwrap();
+    match FileSystem::create_reserved(
+        disk,
+        password_opt.as_ref().map(|x| x.as_bytes()),
+        &bootloader,
+        ctime.as_secs(),
+        ctime.subsec_nanos(),
+    ) {
        Ok(filesystem) => {
-            let uuid = Uuid::from_bytes(&filesystem.header.1.uuid).unwrap();
-            println!("redoxfs-mkfs: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}", disk_path, filesystem.block, filesystem.header.1.size/1000/1000, uuid.hyphenated());
-        },
+            let uuid = Uuid::from_bytes(filesystem.header.uuid());
+            eprintln!(
+                "redoxfs-mkfs: created filesystem on {}, reserved {} blocks, size {} MB, uuid {}",
+                disk_path,
+                filesystem.block,
+                filesystem.header.size() / 1000 / 1000,
+                uuid.hyphenated()
+            );
+        }
        Err(err) => {
-            println!("redoxfs-mkfs: failed to create filesystem on {}: {}", disk_path, err);
+            eprintln!(
+                "redoxfs-mkfs: failed to create filesystem on {}: {}",
+                disk_path, err
+            );
            process::exit(1);
        }
    }

--- a/src/bin/mount.rs
+++ b/src/bin/mount.rs
-#![deny(warnings)]
-#![cfg_attr(unix, feature(libc))]
-
-#[cfg(unix)]
 extern crate libc;
-
+extern crate redoxfs;
 #[cfg(target_os = "redox")]
 extern crate syscall;
-
-extern crate redoxfs;
 extern crate uuid;

 use std::env;
 use std::fs::File;
-use std::io::{Read, Write};
-use std::os::unix::io::FromRawFd;
+use std::io::{self, Read, Write};
+use std::os::unix::io::{FromRawFd, RawFd};
 use std::process;

-use redoxfs::{DiskCache, DiskFile, mount};
+#[cfg(target_os = "redox")]
+use std::{mem::MaybeUninit, ptr::addr_of_mut, sync::atomic::Ordering};
+
+use redoxfs::{mount, DiskCache, DiskFile, FileSystem};
+use termion::input::TermRead;
 use uuid::Uuid;

 #[cfg(target_os = "redox")]
 extern "C" fn unmount_handler(_s: usize) {
-    use std::sync::atomic::Ordering;
    redoxfs::IS_UMT.store(1, Ordering::SeqCst);
 }

@@ -30,45 +27,108 @@ extern "C" fn unmount_handler(_s: usize) {
 //for, so I put 2. I don't think 0,0 is a valid sa_mask. I don't know what i'm doing here. When u
 //send it a sigkill, it shuts off the filesystem
 fn setsig() {
-    use syscall::{sigaction, SigAction, SIGTERM};
-
-    let sig_action = SigAction {
-        sa_handler: unmount_handler,
-        sa_mask: [0,0],
-        sa_flags: 0,
-    };
-
-    sigaction(SIGTERM, Some(&sig_action), None).unwrap();
+    // TODO: High-level wrapper like the nix crate?
+    unsafe {
+        let mut action = MaybeUninit::<libc::sigaction>::uninit();
+
+        assert_eq!(
+            libc::sigemptyset(addr_of_mut!((*action.as_mut_ptr()).sa_mask)),
+            0
+        );
+        addr_of_mut!((*action.as_mut_ptr()).sa_flags).write(0);
+        addr_of_mut!((*action.as_mut_ptr()).sa_sigaction).write(unmount_handler as usize);
+
+        assert_eq!(
+            libc::sigaction(libc::SIGTERM, action.as_ptr(), core::ptr::null_mut()),
+            0
+        );
+    }
 }

-#[cfg(unix)]
+#[cfg(not(target_os = "redox"))]
 // on linux, this is implemented properly, so no need for this unscrupulous nonsense!
-fn setsig() {
-    ()
-}
+fn setsig() {}

-#[cfg(unix)]
 fn fork() -> isize {
    unsafe { libc::fork() as isize }
 }

-#[cfg(unix)]
 fn pipe(pipes: &mut [i32; 2]) -> isize {
    unsafe { libc::pipe(pipes.as_mut_ptr()) as isize }
 }

+#[cfg(not(target_os = "redox"))]
+fn capability_mode() {}
+
+#[cfg(not(target_os = "redox"))]
+fn bootloader_password() -> Option<Vec<u8>> {
+    None
+}
+
 #[cfg(target_os = "redox")]
-fn fork() -> isize {
-    unsafe { syscall::Error::mux(syscall::clone(0)) as isize }
+fn capability_mode() {
+    libredox::call::setrens(0, 0).expect("redoxfs: failed to enter null namespace");
 }

 #[cfg(target_os = "redox")]
-fn pipe(pipes: &mut [usize; 2]) -> isize {
-    syscall::Error::mux(syscall::pipe2(pipes, 0)) as isize
+fn bootloader_password() -> Option<Vec<u8>> {
+    use libredox::call::MmapArgs;
+
+    let addr_env = env::var_os("REDOXFS_PASSWORD_ADDR")?;
+    let size_env = env::var_os("REDOXFS_PASSWORD_SIZE")?;
+
+    let addr = usize::from_str_radix(
+        addr_env.to_str().expect("REDOXFS_PASSWORD_ADDR not valid"),
+        16,
+    )
+    .expect("failed to parse REDOXFS_PASSWORD_ADDR");
+
+    let size = usize::from_str_radix(
+        size_env.to_str().expect("REDOXFS_PASSWORD_SIZE not valid"),
+        16,
+    )
+    .expect("failed to parse REDOXFS_PASSWORD_SIZE");
+
+    let mut password = Vec::with_capacity(size);
+    unsafe {
+        let aligned_size = size.next_multiple_of(syscall::PAGE_SIZE);
+
+        let fd = libredox::Fd::open("memory:physical", libredox::flag::O_CLOEXEC, 0)
+            .expect("failed to open physical memory file");
+
+        let password_map = libredox::call::mmap(MmapArgs {
+            addr: core::ptr::null_mut(),
+            length: aligned_size,
+            prot: libredox::flag::PROT_READ,
+            flags: libredox::flag::MAP_SHARED,
+            fd: fd.raw(),
+            offset: addr as u64,
+        })
+        .expect("failed to map REDOXFS_PASSWORD")
+        .cast::<u8>();
+
+        for i in 0..size {
+            password.push(password_map.add(i).read());
+        }
+
+        let _ = libredox::call::munmap(password_map.cast(), aligned_size);
+    }
+    Some(password)
+}
+
+fn print_err_exit(err: impl AsRef<str>) -> ! {
+    eprintln!("{}", err.as_ref());
+    usage();
+    process::exit(1)
+}
+
+fn print_usage_exit() -> ! {
+    usage();
+    process::exit(1)
 }

 fn usage() {
-    println!("redoxfs [--uuid] [disk or uuid] [mountpoint]");
+    println!("redoxfs --no-daemon [-d] [--uuid] [disk or uuid] [mountpoint] [block in hex]");
 }

 enum DiskId {
@@ -76,179 +136,272 @@ enum DiskId {
    Uuid(Uuid),
 }

-#[cfg(not(target_os = "redox"))]
-fn disk_paths(_paths: &mut Vec<String>) {}
+fn filesystem_by_path(
+    path: &str,
+    block_opt: Option<u64>,
+) -> Option<(String, FileSystem<DiskCache<DiskFile>>)> {
+    println!("redoxfs: opening {}", path);
+    let attempts = 10;
+    for attempt in 0..=attempts {
+        let password_opt = if attempt > 0 {
+            eprint!("redoxfs: password: ");

-#[cfg(target_os = "redox")]
-fn disk_paths(paths: &mut Vec<String>) {
-    use std::fs;
+            let password = io::stdin()
+                .read_passwd(&mut io::stderr())
+                .unwrap()
+                .unwrap_or_default();
+
+            eprintln!();
+
+            if password.is_empty() {
+                eprintln!("redoxfs: empty password, giving up");

-    let mut schemes = vec![];
-    match fs::read_dir(":") {
-        Ok(entries) => for entry_res in entries {
-            if let Ok(entry) = entry_res {
-                if let Ok(path) = entry.path().into_os_string().into_string() {
-                    let scheme = path.trim_left_matches(':').trim_matches('/');
-                    if scheme.starts_with("disk") {
-                        println!("redoxfs: found scheme {}", scheme);
-                        schemes.push(format!("{}:", scheme));
+                // Password is empty, exit loop
+                break;
+            }
+
+            Some(password.into_bytes())
+        } else {
+            bootloader_password()
+        };
+
+        match DiskFile::open(path).map(DiskCache::new) {
+            Ok(disk) => {
+                match redoxfs::FileSystem::open(disk, password_opt.as_deref(), block_opt, true) {
+                    Ok(filesystem) => {
+                        println!(
+                            "redoxfs: opened filesystem on {} with uuid {}",
+                            path,
+                            Uuid::from_bytes(filesystem.header.uuid()).hyphenated()
+                        );
+
+                        return Some((path.to_string(), filesystem));
                    }
+                    Err(err) => match err.errno {
+                        syscall::ENOKEY => {
+                            if password_opt.is_some() {
+                                println!("redoxfs: incorrect password ({}/{})", attempt, attempts);
+                            }
+                        }
+                        _ => {
+                            println!("redoxfs: failed to open filesystem {}: {}", path, err);
+                            break;
+                        }
+                    },
                }
            }
-        },
-        Err(err) => {
-            println!("redoxfs: failed to list schemes: {}", err);
+            Err(err) => {
+                println!("redoxfs: failed to open image {}: {}", path, err);
+                break;
+            }
        }
    }
+    None
+}
+
+#[cfg(not(target_os = "redox"))]
+fn filesystem_by_uuid(
+    _uuid: &Uuid,
+    _block_opt: Option<u64>,
+) -> Option<(String, FileSystem<DiskCache<DiskFile>>)> {
+    None
+}

-    for scheme in schemes {
-        match fs::read_dir(&scheme) {
-            Ok(entries) => for entry_res in entries {
+#[cfg(target_os = "redox")]
+fn filesystem_by_uuid(
+    uuid: &Uuid,
+    block_opt: Option<u64>,
+) -> Option<(String, FileSystem<DiskCache<DiskFile>>)> {
+    use std::fs;
+
+    use redox_path::RedoxPath;
+
+    match fs::read_dir("/scheme") {
+        Ok(entries) => {
+            for entry_res in entries {
                if let Ok(entry) = entry_res {
-                    if let Ok(path) = entry.path().into_os_string().into_string() {
-                        println!("redoxfs: found path {}", path);
-                        paths.push(path);
+                    if let Some(disk) = entry.path().to_str() {
+                        if RedoxPath::from_absolute(disk)
+                            .unwrap_or(RedoxPath::from_absolute("/")?)
+                            .is_scheme_category("disk")
+                        {
+                            println!("redoxfs: found scheme {}", disk);
+                            match fs::read_dir(disk) {
+                                Ok(entries) => {
+                                    for entry_res in entries {
+                                        if let Ok(entry) = entry_res {
+                                            if let Ok(path) =
+                                                entry.path().into_os_string().into_string()
+                                            {
+                                                println!("redoxfs: found path {}", path);
+                                                if let Some((path, filesystem)) =
+                                                    filesystem_by_path(&path, block_opt)
+                                                {
+                                                    if &filesystem.header.uuid() == uuid.as_bytes()
+                                                    {
+                                                        println!(
+                                                            "redoxfs: filesystem on {} matches uuid {}",
+                                                            path,
+                                                            uuid.hyphenated()
+                                                        );
+                                                        return Some((path, filesystem));
+                                                    } else {
+                                                        println!(
+                                                            "redoxfs: filesystem on {} does not match uuid {}",
+                                                            path,
+                                                            uuid.hyphenated()
+                                                        );
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                Err(err) => {
+                                    println!("redoxfs: failed to list '{}': {}", disk, err);
+                                }
+                            }
+                        }
                    }
                }
-            },
-            Err(err) => {
-                println!("redoxfs: failed to list '{}': {}", scheme, err);
            }
        }
+        Err(err) => {
+            println!("redoxfs: failed to list schemes: {}", err);
+        }
    }
+
+    None
 }

-fn daemon(disk_id: &DiskId, mountpoint: &str, mut write: File) -> ! {
+fn daemon(
+    disk_id: &DiskId,
+    mountpoint: &str,
+    block_opt: Option<u64>,
+    mut write: Option<File>,
+) -> ! {
    setsig();

-    let mut paths = vec![];
-    let mut uuid_opt = None;
+    let filesystem_opt = match *disk_id {
+        DiskId::Path(ref path) => filesystem_by_path(path, block_opt),
+        DiskId::Uuid(ref uuid) => filesystem_by_uuid(uuid, block_opt),
+    };

-    match *disk_id {
-        DiskId::Path(ref path) => {
-            paths.push(path.clone());
-        },
-        DiskId::Uuid(ref uuid) => {
-            disk_paths(&mut paths);
-            uuid_opt = Some(uuid.clone());
-        },
-    }
+    if let Some((path, filesystem)) = filesystem_opt {
+        match mount(filesystem, mountpoint, |mounted_path| {
+            capability_mode();

-    for path in paths {
-        println!("redoxfs: opening {}", path);
-        match DiskFile::open(&path).map(|image| DiskCache::new(image)) {
-            Ok(disk) => match redoxfs::FileSystem::open(disk) {
-                Ok(filesystem) => {
-                    println!("redoxfs: opened filesystem on {} with uuid {}", path,
-                             Uuid::from_bytes(&filesystem.header.1.uuid).unwrap().hyphenated());
-
-                    let matches = if let Some(uuid) = uuid_opt {
-                        if &filesystem.header.1.uuid == uuid.as_bytes() {
-                            println!("redoxfs: filesystem on {} matches uuid {}", path, uuid.hyphenated());
-                            true
-                        } else {
-                            println!("redoxfs: filesystem on {} does not match uuid {}", path, uuid.hyphenated());
-                            false
-                        }
-                    } else {
-                        true
-                    };
-
-                    if matches {
-                        match mount(filesystem, &mountpoint, || {
-                            println!("redoxfs: mounted filesystem on {} to {}", path, mountpoint);
-                            let _ = write.write(&[0]);
-                        }) {
-                            Ok(()) => {
-                                process::exit(0);
-                            },
-                            Err(err) => {
-                                println!("redoxfs: failed to mount {} to {}: {}", path, mountpoint, err);
-                            }
-                        }
-                    }
-                },
-                Err(err) => println!("redoxfs: failed to open filesystem {}: {}", path, err)
-            },
-            Err(err) => println!("redoxfs: failed to open image {}: {}", path, err)
+            println!(
+                "redoxfs: mounted filesystem on {} to {}",
+                path,
+                mounted_path.display()
+            );
+
+            if let Some(ref mut write) = write {
+                let _ = write.write(&[0]);
+            }
+        }) {
+            Ok(()) => {
+                process::exit(0);
+            }
+            Err(err) => {
+                println!(
+                    "redoxfs: failed to mount {} to {}: {}",
+                    path, mountpoint, err
+                );
+            }
        }
    }

    match *disk_id {
        DiskId::Path(ref path) => {
            println!("redoxfs: not able to mount path {}", path);
-        },
+        }
        DiskId::Uuid(ref uuid) => {
            println!("redoxfs: not able to mount uuid {}", uuid.hyphenated());
-        },
+        }
+    }
+
+    if let Some(ref mut write) = write {
+        let _ = write.write(&[1]);
    }

-    let _ = write.write(&[1]);
    process::exit(1);
 }

 fn main() {
+    env_logger::init();
+
    let mut args = env::args().skip(1);

-    let disk_id = match args.next() {
-        Some(arg) => if arg == "--uuid" {
-            let uuid = match args.next() {
-                Some(arg) => match Uuid::parse_str(&arg) {
-                    Ok(uuid) => uuid,
-                    Err(err) => {
-                        println!("redoxfs: invalid uuid '{}': {}", arg, err);
-                        usage();
-                        process::exit(1);
-                    }
-                },
-                None => {
-                    println!("redoxfs: no uuid provided");
-                    usage();
-                    process::exit(1);
-                }
-            };
+    let mut daemonise = true;
+    let mut disk_id: Option<DiskId> = None;
+    let mut mountpoint: Option<String> = None;
+    let mut block_opt: Option<u64> = None;
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--no-daemon" | "-d" => daemonise = false,
+
+            "--uuid" if disk_id.is_none() => {
+                disk_id = Some(DiskId::Uuid(
+                    match args.next().as_deref().map(Uuid::parse_str) {
+                        Some(Ok(uuid)) => uuid,
+                        Some(Err(err)) => {
+                            print_err_exit(format!("redoxfs: invalid uuid '{}': {}", arg, err))
+                        }
+                        None => print_err_exit("redoxfs: no uuid provided"),
+                    },
+                ));
+            }

-            DiskId::Uuid(uuid)
-        } else {
-            DiskId::Path(arg)
-        },
-        None => {
-            println!("redoxfs: no disk provided");
-            usage();
-            process::exit(1);
+            disk if disk_id.is_none() => disk_id = Some(DiskId::Path(disk.to_owned())),
+
+            mnt if disk_id.is_some() && mountpoint.is_none() => mountpoint = Some(mnt.to_owned()),
+
+            opts if mountpoint.is_some() => match u64::from_str_radix(opts, 16) {
+                Ok(block) => block_opt = Some(block),
+                Err(err) => print_err_exit(format!("redoxfs: invalid block '{}': {}", opts, err)),
+            },
+
+            _ => print_usage_exit(),
        }
+    }
+
+    let Some(disk_id) = disk_id else {
+        print_err_exit("redoxfs: no disk provided");
    };

-    let mountpoint = match args.next() {
-        Some(arg) => arg,
-        None => {
-            println!("redoxfs: no mountpoint provided");
-            usage();
-            process::exit(1);
-        }
+    let Some(mountpoint) = mountpoint else {
+        print_err_exit("redoxfs: no mountpoint provided");
    };

-    let mut pipes = [0; 2];
-    if pipe(&mut pipes) == 0 {
-        let mut read = unsafe { File::from_raw_fd(pipes[0]) };
-        let write = unsafe { File::from_raw_fd(pipes[1]) };
+    if daemonise {
+        let mut pipes = [0; 2];
+        if pipe(&mut pipes) == 0 {
+            let mut read = unsafe { File::from_raw_fd(pipes[0] as RawFd) };
+            let write = unsafe { File::from_raw_fd(pipes[1] as RawFd) };

-        let pid = fork();
-        if pid == 0 {
-            drop(read);
+            let pid = fork();
+            if pid == 0 {
+                drop(read);

-            daemon(&disk_id, &mountpoint, write);
-        } else if pid > 0 {
-            drop(write);
+                daemon(&disk_id, &mountpoint, block_opt, Some(write));
+            } else if pid > 0 {
+                drop(write);

-            let mut res = [0];
-            read.read(&mut res).unwrap();
+                let mut res = [0];
+                read.read_exact(&mut res).unwrap();

-            process::exit(res[0] as i32);
+                process::exit(res[0] as i32);
+            } else {
+                panic!("redoxfs: failed to fork");
+            }
        } else {
-            panic!("redoxfs: failed to fork");
+            panic!("redoxfs: failed to create pipe");
        }
    } else {
-        panic!("redoxfs: failed to create pipe");
+        println!("redoxfs: running in foreground");
+        daemon(&disk_id, &mountpoint, block_opt, None);
    }
 }
--- a/src/block.rs
+++ b/src/block.rs
+use core::{fmt, marker::PhantomData, mem, ops, slice};
+use endian_num::Le;
+
+use crate::BLOCK_SIZE;
+
+const BLOCK_LIST_ENTRIES: usize = BLOCK_SIZE as usize / mem::size_of::<BlockPtr<BlockRaw>>();
+
+/// An address of a data block.
+///
+/// This encodes a block's position _and_ [`BlockLevel`]:
+/// the first four bits of this `u64` encode the block's level,
+/// the rest encode its index.
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BlockAddr(u64);
+
+impl BlockAddr {
+    // Unsafe because this can create invalid blocks
+    pub(crate) unsafe fn new(index: u64, level: BlockLevel) -> Self {
+        // Level must only use the lowest four bits
+        if level.0 > 0xF {
+            panic!("block level used more than four bits");
+        }
+
+        // Index must not use the highest four bits
+        let inner = index
+            .checked_shl(4)
+            .expect("block index used highest four bits")
+            | (level.0 as u64);
+        Self(inner)
+    }
+
+    pub fn null(level: BlockLevel) -> Self {
+        unsafe { Self::new(0, level) }
+    }
+
+    pub fn index(&self) -> u64 {
+        // The first four bits store the level
+        self.0 >> 4
+    }
+
+    pub fn level(&self) -> BlockLevel {
+        // The first four bits store the level
+        BlockLevel((self.0 & 0xF) as usize)
+    }
+
+    pub fn is_null(&self) -> bool {
+        self.index() == 0
+    }
+}
+
+/// The size of a block.
+///
+/// Level 0 blocks are blocks of [`BLOCK_SIZE`] bytes.
+/// A level 1 block consists of two consecutive level 0 blocks.
+/// A level n block consists of two consecutive level n-1 blocks.
+///
+/// See [`crate::Allocator`] docs for more details.
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BlockLevel(pub(crate) usize);
+
+impl BlockLevel {
+    /// Returns the smallest block level that can contain
+    /// the given number of bytes.
+    pub(crate) fn for_bytes(bytes: u64) -> Self {
+        if bytes == 0 {
+            return BlockLevel(0);
+        }
+        let level = bytes
+            .div_ceil(BLOCK_SIZE)
+            .next_power_of_two()
+            .trailing_zeros() as usize;
+        BlockLevel(level)
+    }
+
+    /// The number of [`BLOCK_SIZE`] blocks (i.e, level 0 blocks)
+    /// in a block of this level
+    pub fn blocks(self) -> i64 {
+        1 << self.0
+    }
+
+    /// The number of bytes in a block of this level
+    pub fn bytes(self) -> u64 {
+        BLOCK_SIZE << self.0
+    }
+}
+
+pub unsafe trait BlockTrait {
+    /// Create an empty block of this type.
+    fn empty(level: BlockLevel) -> Option<Self>
+    where
+        Self: Sized;
+}
+
+/// A [`BlockAddr`] and the data it points to.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BlockData<T> {
+    addr: BlockAddr,
+    data: T,
+}
+
+impl<T> BlockData<T> {
+    pub fn new(addr: BlockAddr, data: T) -> Self {
+        Self { addr, data }
+    }
+
+    pub fn addr(&self) -> BlockAddr {
+        self.addr
+    }
+
+    pub fn data(&self) -> &T {
+        &self.data
+    }
+
+    pub fn data_mut(&mut self) -> &mut T {
+        &mut self.data
+    }
+
+    pub(crate) unsafe fn into_parts(self) -> (BlockAddr, T) {
+        (self.addr, self.data)
+    }
+
+    /// Set the address of this [`BlockData`] to `addr`, returning this
+    /// block's old address. This method does not update block data.
+    ///
+    /// `addr` must point to a block with the same level as this block.
+    #[must_use = "don't forget to de-allocate old block address"]
+    pub fn swap_addr(&mut self, addr: BlockAddr) -> BlockAddr {
+        // Address levels must match
+        assert_eq!(self.addr.level(), addr.level());
+        let old = self.addr;
+        self.addr = addr;
+        old
+    }
+}
+
+impl<T: BlockTrait> BlockData<T> {
+    pub fn empty(addr: BlockAddr) -> Option<Self> {
+        let empty = T::empty(addr.level())?;
+        Some(Self::new(addr, empty))
+    }
+}
+
+impl<T: ops::Deref<Target = [u8]>> BlockData<T> {
+    pub fn create_ptr(&self) -> BlockPtr<T> {
+        BlockPtr {
+            addr: self.addr.0.into(),
+            hash: seahash::hash(self.data.deref()).into(),
+            phantom: PhantomData,
+        }
+    }
+}
+
+#[repr(C, packed)]
+pub struct BlockList<T> {
+    pub ptrs: [BlockPtr<T>; BLOCK_LIST_ENTRIES],
+}
+
+unsafe impl<T> BlockTrait for BlockList<T> {
+    fn empty(level: BlockLevel) -> Option<Self> {
+        if level.0 == 0 {
+            Some(Self {
+                ptrs: [BlockPtr::default(); BLOCK_LIST_ENTRIES],
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl<T> BlockList<T> {
+    pub fn is_empty(&self) -> bool {
+        for ptr in self.ptrs.iter() {
+            if !ptr.is_null() {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl<T> ops::Deref for BlockList<T> {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        unsafe {
+            slice::from_raw_parts(
+                self as *const BlockList<T> as *const u8,
+                mem::size_of::<BlockList<T>>(),
+            ) as &[u8]
+        }
+    }
+}
+
+impl<T> ops::DerefMut for BlockList<T> {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        unsafe {
+            slice::from_raw_parts_mut(
+                self as *mut BlockList<T> as *mut u8,
+                mem::size_of::<BlockList<T>>(),
+            ) as &mut [u8]
+        }
+    }
+}
+
+/// An address of a data block, along with a checksum of its data.
+///
+/// This encodes a block's position _and_ [`BlockLevel`].
+/// the first four bits of `addr` encode the block's level,
+/// the rest encode its index.
+///
+/// Also see [`BlockAddr`].
+#[repr(C, packed)]
+pub struct BlockPtr<T> {
+    addr: Le<u64>,
+    hash: Le<u64>,
+    phantom: PhantomData<T>,
+}
+
+impl<T> BlockPtr<T> {
+    pub fn null(level: BlockLevel) -> Self {
+        Self {
+            addr: BlockAddr::null(level).0.into(),
+            hash: 0.into(),
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn addr(&self) -> BlockAddr {
+        BlockAddr(self.addr.to_ne())
+    }
+
+    pub fn hash(&self) -> u64 {
+        self.hash.to_ne()
+    }
+
+    pub fn is_null(&self) -> bool {
+        self.addr().is_null()
+    }
+
+    /// Cast BlockPtr to another type
+    ///
+    /// # Safety
+    /// Unsafe because it can be used to transmute types
+    pub unsafe fn cast<U>(self) -> BlockPtr<U> {
+        BlockPtr {
+            addr: self.addr,
+            hash: self.hash,
+            phantom: PhantomData,
+        }
+    }
+
+    #[must_use = "the returned pointer should usually be deallocated"]
+    pub fn clear(&mut self) -> BlockPtr<T> {
+        let mut ptr = Self::default();
+        mem::swap(self, &mut ptr);
+        ptr
+    }
+}
+
+impl<T> Clone for BlockPtr<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> Copy for BlockPtr<T> {}
+
+impl<T> Default for BlockPtr<T> {
+    fn default() -> Self {
+        Self {
+            addr: 0.into(),
+            hash: 0.into(),
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<T> fmt::Debug for BlockPtr<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let addr = self.addr();
+        let hash = self.hash();
+        f.debug_struct("BlockPtr")
+            .field("addr", &addr)
+            .field("hash", &hash)
+            .finish()
+    }
+}
+
+#[repr(C, packed)]
+pub struct BlockRaw([u8; BLOCK_SIZE as usize]);
+
+unsafe impl BlockTrait for BlockRaw {
+    fn empty(level: BlockLevel) -> Option<Self> {
+        if level.0 == 0 {
+            Some(Self([0; BLOCK_SIZE as usize]))
+        } else {
+            None
+        }
+    }
+}
+
+impl Clone for BlockRaw {
+    fn clone(&self) -> Self {
+        Self(self.0)
+    }
+}
+
+impl ops::Deref for BlockRaw {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl ops::DerefMut for BlockRaw {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        &mut self.0
+    }
+}
+
+#[test]
+fn block_list_size_test() {
+    assert_eq!(mem::size_of::<BlockList<BlockRaw>>(), BLOCK_SIZE as usize);
+}
+
+#[test]
+fn block_raw_size_test() {
+    assert_eq!(mem::size_of::<BlockRaw>(), BLOCK_SIZE as usize);
+}
--- a/src/dir.rs
+++ b/src/dir.rs
+use alloc::{boxed::Box, vec};
+use core::{mem, ops, slice, str};
+
+use crate::{BlockLevel, BlockTrait, Node, TreePtr, DIR_ENTRY_MAX_LENGTH, RECORD_LEVEL};
+
+#[repr(C, packed)]
+pub struct DirEntry {
+    node_ptr: TreePtr<Node>,
+    name: [u8; DIR_ENTRY_MAX_LENGTH],
+}
+
+impl DirEntry {
+    pub fn new(node_ptr: TreePtr<Node>, name: &str) -> DirEntry {
+        let mut entry = DirEntry {
+            node_ptr,
+            ..Default::default()
+        };
+
+        entry.name[..name.len()].copy_from_slice(name.as_bytes());
+
+        entry
+    }
+
+    pub fn node_ptr(&self) -> TreePtr<Node> {
+        self.node_ptr
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        let mut len = 0;
+        while len < self.name.len() {
+            if self.name[len] == 0 {
+                break;
+            }
+            len += 1;
+        }
+        //TODO: report utf8 error?
+        str::from_utf8(&self.name[..len]).ok()
+    }
+}
+
+impl Clone for DirEntry {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl Copy for DirEntry {}
+
+impl Default for DirEntry {
+    fn default() -> Self {
+        Self {
+            node_ptr: TreePtr::default(),
+            name: [0; DIR_ENTRY_MAX_LENGTH],
+        }
+    }
+}
+
+//TODO: this is a box to prevent stack overflows
+pub struct DirList {
+    pub entries: Box<[DirEntry]>,
+}
+
+unsafe impl BlockTrait for DirList {
+    fn empty(level: BlockLevel) -> Option<Self> {
+        if level.0 <= RECORD_LEVEL {
+            let entries = level.bytes() as usize / mem::size_of::<DirEntry>();
+            Some(Self {
+                entries: vec![DirEntry::default(); entries].into_boxed_slice(),
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl DirList {
+    pub fn is_empty(&self) -> bool {
+        for entry in self.entries.iter() {
+            if !entry.node_ptr().is_null() {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl ops::Deref for DirList {
+    type Target = [u8];
+    fn deref(&self) -> &[u8] {
+        unsafe {
+            slice::from_raw_parts(
+                self.entries.as_ptr() as *const u8,
+                self.entries.len() * mem::size_of::<DirEntry>(),
+            ) as &[u8]
+        }
+    }
+}
+
+impl ops::DerefMut for DirList {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        unsafe {
+            slice::from_raw_parts_mut(
+                self.entries.as_mut_ptr() as *mut u8,
+                self.entries.len() * mem::size_of::<DirEntry>(),
+            ) as &mut [u8]
+        }
+    }
+}
+
+#[test]
+fn dir_list_size_test() {
+    use core::ops::Deref;
+    for level_i in 0..RECORD_LEVEL {
+        let level = BlockLevel(level_i);
+        assert_eq!(
+            DirList::empty(level).unwrap().deref().len(),
+            level.bytes() as usize
+        );
+    }
+}
--- a/src/disk/cache.rs
+++ b/src/disk/cache.rs
-use std::{cmp, ptr};
 use std::collections::{HashMap, VecDeque};
+use std::{cmp, ptr};
 use syscall::error::Result;

-use BLOCK_SIZE;
-use disk::Disk;
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;

 fn copy_memory(src: &[u8], dest: &mut [u8]) -> usize {
    let len = cmp::min(src.len(), dest.len());
@@ -20,11 +20,13 @@ pub struct DiskCache<T> {

 impl<T: Disk> DiskCache<T> {
    pub fn new(inner: T) -> Self {
+        // 16 MB cache
+        let size = 16 * 1024 * 1024 / BLOCK_SIZE as usize;
        DiskCache {
-            inner: inner,
-            cache: HashMap::new(),
-            order: VecDeque::new(),
-            size: 65536, // 256 MB cache
+            inner,
+            cache: HashMap::with_capacity(size),
+            order: VecDeque::with_capacity(size),
+            size,
        }
    }

@@ -40,21 +42,21 @@ impl<T: Disk> DiskCache<T> {
 }

 impl<T: Disk> Disk for DiskCache<T> {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
        // println!("Cache read at {}", block);

        let mut read = 0;
        let mut failed = false;
-        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
            let block_i = block + i as u64;

            let buffer_i = i * BLOCK_SIZE as usize;
            let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-            let buffer_slice = &mut buffer[buffer_i .. buffer_j];
+            let buffer_slice = &mut buffer[buffer_i..buffer_j];

            if let Some(cache_buf) = self.cache.get_mut(&block_i) {
                read += copy_memory(cache_buf, buffer_slice);
-            }else{
+            } else {
                failed = true;
                break;
            }
@@ -64,12 +66,12 @@ impl<T: Disk> Disk for DiskCache<T> {
            self.inner.read_at(block, buffer)?;

            read = 0;
-            for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+            for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
                let block_i = block + i as u64;

                let buffer_i = i * BLOCK_SIZE as usize;
                let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-                let buffer_slice = &buffer[buffer_i .. buffer_j];
+                let buffer_slice = &buffer[buffer_i..buffer_j];

                let mut cache_buf = [0; BLOCK_SIZE as usize];
                read += copy_memory(buffer_slice, &mut cache_buf);
@@ -80,18 +82,19 @@ impl<T: Disk> Disk for DiskCache<T> {
        Ok(read)
    }

-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+        //TODO: Write only blocks that have changed
        // println!("Cache write at {}", block);

        self.inner.write_at(block, buffer)?;

        let mut written = 0;
-        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1)/(BLOCK_SIZE as usize) {
+        for i in 0..(buffer.len() + BLOCK_SIZE as usize - 1) / (BLOCK_SIZE as usize) {
            let block_i = block + i as u64;

            let buffer_i = i * BLOCK_SIZE as usize;
            let buffer_j = cmp::min(buffer_i + BLOCK_SIZE as usize, buffer.len());
-            let buffer_slice = &buffer[buffer_i .. buffer_j];
+            let buffer_slice = &buffer[buffer_i..buffer_j];

            let mut cache_buf = [0; BLOCK_SIZE as usize];
            written += copy_memory(buffer_slice, &mut cache_buf);

--- a/src/disk/file.rs
+++ b/src/disk/file.rs
 use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
+use std::io::{Seek, SeekFrom};
+use std::os::unix::fs::FileExt;
+use std::path::Path;
+
 use syscall::error::{Error, Result, EIO};

-use BLOCK_SIZE;
-use disk::Disk;
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;

-macro_rules! try_disk {
-    ($expr:expr) => (match $expr {
-        Ok(val) => val,
-        Err(err) => {
-            eprintln!("Disk I/O Error: {}", err);
-            return Err(Error::new(EIO));
-        }
-    })
+pub struct DiskFile {
+    pub file: File,
 }

-pub struct DiskFile {
-    file: File
+trait ResultExt {
+    type T;
+    fn or_eio(self) -> Result<Self::T>;
+}
+impl<T> ResultExt for Result<T> {
+    type T = T;
+    fn or_eio(self) -> Result<Self::T> {
+        match self {
+            Ok(t) => Ok(t),
+            Err(err) => {
+                eprintln!("RedoxFS: IO ERROR: {err}");
+                Err(Error::new(EIO))
+            }
+        }
+    }
+}
+impl<T> ResultExt for std::io::Result<T> {
+    type T = T;
+    fn or_eio(self) -> Result<Self::T> {
+        match self {
+            Ok(t) => Ok(t),
+            Err(err) => {
+                eprintln!("RedoxFS: IO ERROR: {err}");
+                Err(Error::new(EIO))
+            }
+        }
+    }
 }

 impl DiskFile {
-    pub fn open(path: &str) -> Result<DiskFile> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).open(path));
-        Ok(DiskFile {
-            file: file
-        })
+    pub fn open(path: impl AsRef<Path>) -> Result<DiskFile> {
+        let file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .open(path)
+            .or_eio()?;
+        Ok(DiskFile { file })
    }

-    pub fn create(path: &str, size: u64) -> Result<DiskFile> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).create(true).open(path));
-        try_disk!(file.set_len(size));
-        Ok(DiskFile {
-            file: file
-        })
+    pub fn create(path: impl AsRef<Path>, size: u64) -> Result<DiskFile> {
+        let file = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(path)
+            .or_eio()?;
+        file.set_len(size).or_eio()?;
+        Ok(DiskFile { file })
    }
 }

 impl Disk for DiskFile {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
-        let count = try_disk!(self.file.read(buffer));
-        Ok(count)
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+        self.file.read_at(buffer, block * BLOCK_SIZE).or_eio()
    }

-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * BLOCK_SIZE)));
-        let count = try_disk!(self.file.write(buffer));
-        Ok(count)
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+        self.file.write_at(buffer, block * BLOCK_SIZE).or_eio()
    }

    fn size(&mut self) -> Result<u64> {
-        let size = try_disk!(self.file.seek(SeekFrom::End(0)));
-        Ok(size)
+        self.file.seek(SeekFrom::End(0)).or_eio()
    }
 }
--- a/src/disk/io.rs
+++ b/src/disk/io.rs
+use std::io::{Read, Seek, SeekFrom, Write};
+use syscall::error::{Error, Result, EIO};
+
+use crate::disk::Disk;
+use crate::BLOCK_SIZE;
+
+macro_rules! try_disk {
+    ($expr:expr) => {
+        match $expr {
+            Ok(val) => val,
+            Err(err) => {
+                eprintln!("Disk I/O Error: {}", err);
+                return Err(Error::new(EIO));
+            }
+        }
+    };
+}
+
+pub struct DiskIo<T>(pub T);
+
+impl<T: Read + Write + Seek> Disk for DiskIo<T> {
+    unsafe fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
+        try_disk!(self.0.seek(SeekFrom::Start(block * BLOCK_SIZE)));
+        let count = try_disk!(self.0.read(buffer));
+        Ok(count)
+    }
+
+    unsafe fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
+        try_disk!(self.0.seek(SeekFrom::Start(block * BLOCK_SIZE)));
+        let count = try_disk!(self.0.write(buffer));
+        Ok(count)
+    }
+
+    fn size(&mut self) -> Result<u64> {
+        let size = try_disk!(self.0.seek(SeekFrom::End(0)));
+        Ok(size)
+    }
+}
No results found