diff --git a/Cargo.lock b/Cargo.lock
index 83fc35b..3caec75 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,15 +2,6 @@
 # It is not intended for manual editing.
 version = 4
 
-[[package]]
-name = "aho-corasick"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -26,56 +17,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "anstream"
-version = "0.6.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301af1932e46185686725e0fad2f8f2aa7da69dd70bf6ecc44d6b703844a3933"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c8bdeb6047d8983be085bab0ba1472e6dc604e7041dbf6fcd5e71523014fae9"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "403f75924867bb1033c59fbf0797484329750cfbe3c4325cd33127941fabc882"
-dependencies = [
- "anstyle",
- "once_cell_polyfill",
- "windows-sys",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.98"
@@ -100,21 +41,6 @@ version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
-[[package]]
-name = "castaway"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cc"
 version = "1.2.30"
@@ -148,52 +74,12 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "colorchoice"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
-
-[[package]]
-name = "compact_str"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
-]
-
-[[package]]
-name = "compact_string"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5255b88d8ea09573f588088dea17fbea682b4442abea6761a15d1da2c3a76c5c"
-dependencies = [
- "serde",
- "thiserror 1.0.69",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
-[[package]]
-name = "ctrlc"
-version = "3.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f93780a459b7d656ef7f071fe699c4d3d2cb201c4b24d085b6ddc505276e73"
-dependencies = [
- "nix 0.30.1",
- "windows-sys",
-]
-
 [[package]]
 name = "enum_dispatch"
 version = "0.3.13"
@@ -206,29 +92,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "env_filter"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
-dependencies = [
- "log",
- "regex",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.11.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
-dependencies = [
- "anstream",
- "anstyle",
- "env_filter",
- "jiff",
- "log",
-]
-
 [[package]]
 name = "fat-bits"
 version = "0.1.0"
@@ -236,11 +99,9 @@ dependencies = [
  "anyhow",
  "bitflags",
  "chrono",
- "compact_str",
  "enum_dispatch",
- "log",
  "static_assertions",
- "thiserror 2.0.12",
+ "thiserror",
 ]
 
 [[package]]
@@ -256,27 +117,13 @@ name = "fat-fuse"
 version = "0.1.0"
 dependencies = [
  "anyhow",
- "bitflags",
  "chrono",
- "compact_string",
  "fat-bits",
  "fuser",
- "fxhash",
  "libc",
  "log",
  "rand",
- "thiserror 2.0.12",
-]
-
-[[package]]
-name = "fat-mount"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "ctrlc",
- "env_logger",
- "fat-fuse",
- "fuser",
+ "thiserror",
 ]
 
 [[package]]
@@ -288,22 +135,13 @@ dependencies = [
  "libc",
  "log",
  "memchr",
- "nix 0.29.0",
+ "nix",
  "page_size",
  "pkg-config",
  "smallvec",
  "zerocopy",
 ]
 
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.3.3"
@@ -340,42 +178,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
-[[package]]
-name = "itoa"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
-
-[[package]]
-name = "jiff"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be1f93b8b1eb69c77f24bbb0afdf66f54b632ee39af40ca21c4365a1d7347e49"
-dependencies = [
- "jiff-static",
- "log",
- "portable-atomic",
- "portable-atomic-util",
- "serde",
-]
-
-[[package]]
-name = "jiff-static"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03343451ff899767262ec32146f6d559dd759fdadf42ff0e227c7c48f72594b4"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -416,18 +218,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "nix"
-version = "0.30.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
-dependencies = [
- "bitflags",
- "cfg-if",
- "cfg_aliases",
- "libc",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -443,12 +233,6 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
-[[package]]
-name = "once_cell_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
-
 [[package]]
 name = "page_size"
 version = "0.6.0"
@@ -465,21 +249,6 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
-[[package]]
-name = "portable-atomic-util"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
-dependencies = [
- "portable-atomic",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -522,67 +291,12 @@ dependencies = [
  "getrandom",
 ]
 
-[[package]]
-name = "regex"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
-
 [[package]]
 name = "rustversion"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
 
-[[package]]
-name = "ryu"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
-
-[[package]]
-name = "serde"
-version = "1.0.219"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.219"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "shlex"
 version = "1.3.0"
@@ -612,33 +326,13 @@ dependencies = [
  "unicode-ident",
 ]
 
-[[package]]
-name = "thiserror"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
-dependencies = [
- "thiserror-impl 1.0.69",
-]
-
 [[package]]
 name = "thiserror"
 version = "2.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
 dependencies = [
- "thiserror-impl 2.0.12",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "thiserror-impl",
 ]
 
 [[package]]
@@ -658,12 +352,6 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
-
 [[package]]
 name = "wasi"
 version = "0.14.2+wasi-0.2.4"
@@ -812,79 +500,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.59.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
-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.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.52.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
-
 [[package]]
 name = "wit-bindgen-rt"
 version = "0.39.0"
diff --git a/Cargo.toml b/Cargo.toml
index e944d31..d353d2e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,3 @@
 [workspace]
 resolver = "3"
-members = ["fat-bits", "fat-dump", "fat-fuse", "fat-mount"]
+members = ["fat-bits", "fat-dump", "fat-fuse"]
diff --git a/README.md b/README.md
index 21eb279..f9e1a4d 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1 @@
-# FUSE implementation for the FAT file system
-
-End-to-end implementation of a FAT driver, with the goal of being able to mount disk images with complete read-write support.
-
-Uses (fuser)[https://docs.rs/fuser/latest/fuser/] as the underlying FUSE library.
-
-## Specification
-
-[https://academy.cba.mit.edu/classes/networking_communications/SD/FAT.pdf](https://academy.cba.mit.edu/classes/networking_communications/SD/FAT.pdf)
+specification: [https://academy.cba.mit.edu/classes/networking_communications/SD/FAT.pdf](https://academy.cba.mit.edu/classes/networking_communications/SD/FAT.pdf)
diff --git a/fat-bits/Cargo.toml b/fat-bits/Cargo.toml
index 632d910..1986af5 100644
--- a/fat-bits/Cargo.toml
+++ b/fat-bits/Cargo.toml
@@ -8,11 +8,8 @@ anyhow = "1.0.98"
 bitflags = "2.9.1"
 chrono = { version = "0.4.41", default-features = false, features = [
     "alloc",
-    "clock",
     "std",
 ] }
-compact_str = "0.9.0"
 enum_dispatch = "0.3.13"
-log = "0.4.27"
 static_assertions = "1.1.0"
 thiserror = "2.0.12"
diff --git a/fat-bits/src/bpb.rs b/fat-bits/src/bpb.rs
index 362346c..26e4223 100644
--- a/fat-bits/src/bpb.rs
+++ b/fat-bits/src/bpb.rs
@@ -236,7 +236,6 @@ impl Bpb {
         if self.fat_type() == FatType::Fat32 {
             return None;
         }
-
         Some(self.fat_offset() + self.sector_to_offset(self.num_fats() as u32 * self.fat_size()))
     }
 
diff --git a/fat-bits/src/datetime.rs b/fat-bits/src/datetime.rs
index 6c8e034..b9672f2 100644
--- a/fat-bits/src/datetime.rs
+++ b/fat-bits/src/datetime.rs
@@ -1,6 +1,8 @@
-use chrono::{DateTime, Datelike, Local, NaiveDate, NaiveTime, Timelike};
+use std::time::SystemTime;
 
-#[derive(Debug, Clone, Copy)]
+use chrono::{DateTime, Datelike, NaiveDate, NaiveTime, Timelike, Utc};
+
+#[derive(Debug)]
 pub struct Date {
     repr: u16,
 }
@@ -20,7 +22,8 @@ impl Date {
         Ok(date)
     }
 
-    fn from_day_month_year(day: u8, month: u8, year: u16) -> anyhow::Result<Date> {
+    #[allow(dead_code)]
+    pub fn from_day_month_year(day: u8, month: u8, year: u16) -> anyhow::Result<Date> {
         anyhow::ensure!(day <= 31, "invalid day: {}", day);
         anyhow::ensure!(month <= 12, "invalid month: {}", month);
         anyhow::ensure!(1980 <= year && year <= 2107, "invalid year: {}", year);
@@ -30,7 +33,10 @@ impl Date {
         Ok(Date { repr })
     }
 
-    pub fn from_datetime(datetime: DateTime<Local>) -> anyhow::Result<Date> {
+    #[allow(dead_code)]
+    pub fn from_system_time(time: SystemTime) -> anyhow::Result<Date> {
+        let datetime: DateTime<Utc> = time.into();
+
         let date = datetime.date_naive();
 
         Date::from_day_month_year(
@@ -40,10 +46,6 @@ impl Date {
         )
     }
 
-    pub fn repr(&self) -> u16 {
-        self.repr
-    }
-
     pub fn day(&self) -> u8 {
         (self.repr & 0x1F) as u8
     }
@@ -61,7 +63,7 @@ impl Date {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug)]
 pub struct Time {
     repr: u16,
 }
@@ -73,7 +75,8 @@ impl Time {
         Ok(time)
     }
 
-    fn from_seconds_minutes_hours(seconds: u8, minutes: u8, hours: u8) -> anyhow::Result<Time> {
+    #[allow(dead_code)]
+    pub fn from_seconds_minutes_hours(seconds: u8, minutes: u8, hours: u8) -> anyhow::Result<Time> {
         anyhow::ensure!(seconds <= 58 && seconds % 2 == 0, "invalid seconds: {}", seconds);
         anyhow::ensure!(minutes <= 59, "invalid minutes: {}", minutes);
         anyhow::ensure!(hours <= 23, "invalid hours: {}", hours);
@@ -83,7 +86,10 @@ impl Time {
         Ok(Time { repr })
     }
 
-    pub fn from_datetime(datetime: DateTime<Local>) -> anyhow::Result<Time> {
+    #[allow(dead_code)]
+    pub fn from_system_time(time: SystemTime) -> anyhow::Result<Time> {
+        let datetime: DateTime<Utc> = time.into();
+
         let time = datetime.time();
 
         let seconds = (time.second() as u8) & !0x01;
@@ -91,10 +97,6 @@ impl Time {
         Time::from_seconds_minutes_hours(seconds, time.minute() as u8, time.hour() as u8)
     }
 
-    pub fn repr(&self) -> u16 {
-        self.repr
-    }
-
     pub fn second(&self) -> u8 {
         2 * (self.repr & 0x1F) as u8
     }
diff --git a/fat-bits/src/dir.rs b/fat-bits/src/dir.rs
index 8b8ab6c..be69a54 100644
--- a/fat-bits/src/dir.rs
+++ b/fat-bits/src/dir.rs
@@ -1,16 +1,10 @@
 use std::fmt::Display;
-use std::io::{Read, Write};
-use std::time::SystemTime;
+use std::io::Read;
 
 use bitflags::bitflags;
-use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, TimeDelta, Timelike};
-use compact_str::CompactString;
-use log::debug;
+use chrono::{NaiveDate, NaiveDateTime, TimeDelta};
 
-use crate::FatFs;
 use crate::datetime::{Date, Time};
-use crate::iter::ClusterChainReader;
-use crate::subslice::SubSliceMut;
 use crate::utils::{load_u16_le, load_u32_le};
 
 bitflags! {
@@ -70,29 +64,30 @@ pub struct DirEntry {
 
     file_size: u32,
 
-    checksum: u8,
-    long_name: Option<CompactString>,
-
-    n_longname_slots: u8,
-
-    offset: u64,
+    // buffer for holding short name str representation
+    // initial dot if hidden (1)
+    // stem (8)
+    // dot (1)
+    // extension (3)
+    short_name: [u8; 13],
+    long_name: Option<String>,
 }
 
 impl Display for DirEntry {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut name = self.name_string();
+        let name = self.name_str().unwrap_or("<unknown>");
 
-        if self.attr.contains(Attr::Directory) {
-            name.push('/');
-        }
+        // add slash to end of dir_names
+        let dir_slash = if self.is_dir() { "/" } else { " " };
 
         write!(
             f,
-            "{}    {}",
+            "{}    {}{}",
             self.attr,
             // self.create_time().format("%a %b %d %H:%M:%S%.3f %Y"),
             // self.write_time().format("%a %b %d %H:%M:%S%.3f %Y"),
             name,
+            dir_slash,
         )?;
 
         Ok(())
@@ -100,13 +95,12 @@ impl Display for DirEntry {
 }
 
 impl DirEntry {
-    pub fn load(bytes: &[u8], offset: u64) -> anyhow::Result<DirEntry> {
+    pub fn load(bytes: &[u8]) -> anyhow::Result<DirEntry> {
         assert_eq!(bytes.len(), 32);
 
+        let name: [u8; 11] = bytes[..11].try_into().unwrap();
         let attr = Attr::from_bits_truncate(bytes[11]);
 
-        let name = bytes[..11].try_into().unwrap();
-
         let create_time_tenths = bytes[13];
         anyhow::ensure!(
             create_time_tenths <= 199,
@@ -142,6 +136,32 @@ impl DirEntry {
             )
         }
 
+        let mut short_name = [0; 13];
+
+        let mut short_name_iter = short_name.iter_mut();
+
+        if attr.contains(Attr::Hidden) {
+            // if hidden: lead with '.'
+            *short_name_iter.next().unwrap() = b'.';
+        }
+
+        if name[0] != 0 && name[0] != 0xe5 {
+            // dir_entry is not free
+
+            for c in name[..8].iter().filter(|&x| x != &0x20) {
+                *short_name_iter.next().unwrap() = *c;
+            }
+
+            if &name[8..] != &[0x20, 0x20, 0x20] {
+                // if extension is not empty: add dot and extension
+                *short_name_iter.next().unwrap() = b'.';
+
+                for c in name[8..].iter().filter(|&x| x != &0x20) {
+                    *short_name_iter.next().unwrap() = *c;
+                }
+            }
+        }
+
         Ok(DirEntry {
             name,
             attr,
@@ -153,95 +173,11 @@ impl DirEntry {
             write_time,
             write_date,
             file_size,
+            short_name,
             long_name: None,
-            n_longname_slots: 0,
-            checksum: Self::checksum(&bytes[..11]),
-            offset,
         })
     }
 
-    pub fn create(_name: &str, attr: Attr) -> anyhow::Result<Self> {
-        // TODO
-        let now: DateTime<Local> = SystemTime::now().into();
-
-        let create_date = Date::from_datetime(now)?;
-        let create_time = Time::from_datetime(now)?;
-        let create_time_tenths = (now.time().nanosecond() / 100_000_000) as u8;
-
-        let name = [0; 11];
-
-        Ok(DirEntry {
-            name,
-            attr,
-            create_time_tenths,
-            create_time,
-            create_date,
-            last_access_date: create_date,
-            first_cluster: 0,
-            write_time: create_time,
-            write_date: create_date,
-            file_size: 0,
-            checksum: Self::checksum(&name),
-            long_name: None,
-            n_longname_slots: 0,
-            offset: !0,
-        })
-    }
-
-    fn write(&self, mut writer: impl Write) -> std::io::Result<()> {
-        let mut buf = [0; 32];
-
-        buf[..11].copy_from_slice(self.name());
-
-        buf[11] = self.attr().bits();
-
-        buf[12] = 0;
-
-        buf[13] = self.create_time_tenths;
-        buf[13..15].copy_from_slice(&self.create_time.repr().to_le_bytes());
-
-        buf[16..18].copy_from_slice(&self.create_date.repr().to_le_bytes());
-
-        buf[18..20].copy_from_slice(&self.last_access_date.repr().to_le_bytes());
-
-        buf[20..22].copy_from_slice(&((self.first_cluster() >> 16) as u16).to_le_bytes());
-
-        buf[22..24].copy_from_slice(&self.write_time.repr().to_le_bytes());
-        buf[24..26].copy_from_slice(&self.write_date.repr().to_le_bytes());
-
-        buf[26..28].copy_from_slice(&(self.first_cluster as u16).to_le_bytes());
-
-        buf[28..].copy_from_slice(&self.file_size.to_le_bytes());
-
-        debug!("self: {self:?}");
-        debug!("writing new dir entry: {:?}", buf);
-
-        writer.write_all(&buf)?;
-
-        Ok(())
-    }
-
-    /// write this DisEntry back to the underlying data
-    pub fn write_back(&self, fat_fs: &FatFs) -> std::io::Result<()> {
-        eprintln!("making new SubSliceMut at offset {:#X}", self.offset);
-        let sub_slice = SubSliceMut::new(fat_fs.inner.clone(), self.offset, 32);
-
-        self.write(sub_slice)
-    }
-
-    /// erase this DirEntry
-    pub fn erase(self, fat_fs: &FatFs) -> std::io::Result<()> {
-        let mut sub_slice = SubSliceMut::new(fat_fs.inner.clone(), self.offset, 32);
-
-        // set first byte to 0xE5 (free)
-        sub_slice.write_all(&[0xe5])?;
-
-        // paste over with zeros
-        sub_slice.write_all(&[0; 31])
-
-        // TODO: erase long filename entries as well
-    }
-
     /// indicates this DirEntry is empty
     ///
     /// can be either simply empty (0xe5) or the sentinel (0x00) that indicates that all following
@@ -270,6 +206,8 @@ impl DirEntry {
             return false;
         }
 
+        // &self.name[..2] == &[b'.', b' ']
+
         self.name[0] == b'.' && &self.name[1..] == &[b' '; 10]
     }
 
@@ -278,6 +216,8 @@ impl DirEntry {
             return false;
         }
 
+        // &self.name[..3] == &[b'.', b'.', b' ']
+
         &self.name[..2] == &[b'.', b'.'] && &self.name[2..] == &[b' '; 9]
     }
 
@@ -309,60 +249,54 @@ impl DirEntry {
         std::str::from_utf8(self.extension()).ok()
     }
 
-    pub fn name_string(&self) -> CompactString {
-        // use a CompactString here to allow inlining of short names
-        // maybe switch to a Cow instead? has disadvantage that we need to alloc for short names
+    fn short_name(&self) -> &[u8] {
+        &self.short_name
+    }
 
-        // can't be empty
-        assert!(!self.is_empty());
+    fn short_name_str(&self) -> Option<&str> {
+        let mut short_name = self.short_name();
 
-        if let Some(long_filename) = self.long_name() {
-            return long_filename.into();
+        // remove trailing zeros
+        while short_name.last() == Some(&0) {
+            short_name = &short_name[..short_name.len() - 1];
         }
 
-        let name = &self.name[..8];
-        let ext = &self.name[8..];
-
-        let mut s = CompactString::const_new("");
-
-        if self.attr.contains(Attr::Hidden) {
-            s.push('.');
-        }
-
-        const VALID_SYMBOLS: &[u8] = &[
-            b'$', b'%', b'\'', b'-', b'_', b'@', b'~', b'`', b'!', b'(', b')', b'{', b'}', b'^',
-            b'#', b'&',
-        ];
-
-        fn map_chars(c: u8) -> char {
-            if !c.is_ascii()
-                || c < 0x20
-                || !(c.is_ascii_alphanumeric() || VALID_SYMBOLS.contains(&c))
-            {
-                '?'
-            } else {
-                (c as char).to_ascii_uppercase()
-            }
-        }
-
-        s.extend(name.trim_ascii_end().iter().copied().map(map_chars));
-
-        if !ext.is_empty() {
-            s.push('.');
-
-            s.extend(ext.trim_ascii_end().iter().copied().map(map_chars));
-        }
-
-        s
+        std::str::from_utf8(short_name).ok()
     }
 
     pub fn long_name(&self) -> Option<&str> {
         self.long_name.as_deref()
     }
 
-    pub fn set_long_name(&mut self, long_name: CompactString, n_slots: u8) {
+    pub fn set_long_name(&mut self, long_name: String) {
         self.long_name = Some(long_name);
-        self.n_longname_slots = n_slots;
+    }
+
+    pub fn name_str(&self) -> Option<&str> {
+        if let Some(long_filename) = self.long_name() {
+            return Some(long_filename);
+        }
+
+        self.short_name_str()
+
+        // let name = std::str::from_utf8(&self.name[..8]).ok()?.trim_ascii_end();
+        // let ext = std::str::from_utf8(&self.name[8..]).ok()?.trim_ascii_end();
+
+        // let mut s = String::new();
+
+        // if self.attr.contains(Attr::Hidden) {
+        //     s.push('.');
+        // }
+
+        // s += name;
+
+        // if !ext.is_empty() {
+        //     s.push('.');
+
+        //     s += ext;
+        // }
+
+        // Some(s)
     }
 
     pub fn attr(&self) -> Attr {
@@ -384,15 +318,6 @@ impl DirEntry {
         self.last_access_date.to_naive_date()
     }
 
-    pub fn update_last_access_date(
-        &mut self,
-        time: impl Into<DateTime<Local>>,
-    ) -> anyhow::Result<()> {
-        self.last_access_date = Date::from_datetime(time.into())?;
-
-        Ok(())
-    }
-
     pub fn first_cluster(&self) -> u32 {
         self.first_cluster
     }
@@ -404,27 +329,14 @@ impl DirEntry {
         NaiveDateTime::new(date, time)
     }
 
-    pub fn update_write_time(&mut self, time: impl Into<DateTime<Local>>) -> anyhow::Result<()> {
-        let time = time.into();
-
-        self.write_date = Date::from_datetime(time)?;
-        self.write_time = Time::from_datetime(time)?;
-
-        Ok(())
-    }
-
     pub fn file_size(&self) -> u32 {
         self.file_size
     }
 
-    pub fn update_file_size(&mut self, file_size: u32) {
-        self.file_size = file_size
-    }
-
-    pub fn checksum(name: &[u8]) -> u8 {
+    pub fn checksum(&self) -> u8 {
         let mut checksum: u8 = 0;
 
-        for &x in name {
+        for &x in self.name() {
             checksum = checksum.rotate_right(1).wrapping_add(x);
         }
 
@@ -435,7 +347,6 @@ impl DirEntry {
 /// long filename entry in a directory
 ///
 /// this should not be exposed to end users, only for internal consumption in the DirIter
-#[derive(Debug)]
 struct LongNameDirEntry {
     ordinal: u8,
     is_last: bool,
@@ -510,14 +421,13 @@ impl LongNameDirEntry {
 ///
 /// should not be exposed publicly, end users only see DirEntries
 /// just for making the bytes -> DirEntry loading a bit easier
-#[derive(Debug)]
 enum DirEntryWrapper {
     Regular(DirEntry),
     LongName(LongNameDirEntry),
 }
 
 impl DirEntryWrapper {
-    pub fn load(bytes: &[u8], offset: u64) -> anyhow::Result<DirEntryWrapper> {
+    pub fn load(bytes: &[u8]) -> anyhow::Result<DirEntryWrapper> {
         assert_eq!(bytes.len(), 32);
 
         let attr = Attr::from_bits_truncate(bytes[11]);
@@ -525,7 +435,7 @@ impl DirEntryWrapper {
         let dir_entry = if attr == Attr::LongName {
             DirEntryWrapper::LongName(LongNameDirEntry::load(bytes)?)
         } else {
-            DirEntryWrapper::Regular(DirEntry::load(bytes, offset)?)
+            DirEntryWrapper::Regular(DirEntry::load(bytes)?)
         };
 
         Ok(dir_entry)
@@ -537,7 +447,6 @@ struct LongFilenameBuf {
     rev_buf: Vec<u16>,
     checksum: Option<u8>,
     last_ordinal: Option<u8>,
-    n_slots: u8,
 }
 
 impl LongFilenameBuf {
@@ -545,43 +454,28 @@ impl LongFilenameBuf {
         self.rev_buf.clear();
         self.checksum = None;
         self.last_ordinal = None;
-        self.n_slots = 0;
     }
 
     pub fn next(&mut self, dir_entry: LongNameDirEntry) -> anyhow::Result<()> {
         if dir_entry.is_last() {
             // first/lasts entry
 
-            anyhow::ensure!(
-                dir_entry.ordinal() <= 20,
-                "can't have more than 20 long filename dir entries"
-            );
-
             let mut name = dir_entry.name();
 
             while name.last() == Some(&0xFFFF) {
                 name = &name[..name.len() - 1];
             }
 
-            if name.last() == Some(&0) {
-                name = &name[..name.len() - 1];
-            } else {
-                // no null terminator only for names that are multiples of 13, i.e. perfectly fit
-                assert_eq!(name.len(), 13);
-            }
-
             assert!(!name.is_empty());
 
             self.extend_name(name);
             self.checksum = Some(dir_entry.checksum());
             self.last_ordinal = Some(dir_entry.ordinal());
 
-            self.n_slots += 1;
-
             return Ok(());
         }
 
-        assert!(self.checksum.is_some() && self.last_ordinal.is_some());
+        assert!(self.checksum.is_some());
 
         anyhow::ensure!(
             self.checksum == Some(dir_entry.checksum()),
@@ -609,10 +503,7 @@ impl LongFilenameBuf {
         self.rev_buf.extend(name.iter().rev());
     }
 
-    pub fn get_buf(
-        &mut self,
-        checksum: u8,
-    ) -> anyhow::Result<Option<(impl Iterator<Item = u16>, u8)>> {
+    pub fn get_buf(&mut self, checksum: u8) -> anyhow::Result<Option<impl Iterator<Item = u16>>> {
         if self.checksum.is_none() {
             return Ok(None);
         }
@@ -634,97 +525,100 @@ impl LongFilenameBuf {
             self.checksum.unwrap()
         );
 
-        anyhow::ensure!(self.rev_buf.len() <= 255, "long filename too long");
-
-        Ok(Some((self.rev_buf.iter().copied().rev(), self.n_slots)))
+        Ok(Some(self.rev_buf.iter().copied().rev()))
     }
 }
 
-pub struct DirIter<'a> {
-    reader: ClusterChainReader<'a>,
+pub struct DirIter<R: Read> {
+    reader: R,
 
+    // long_filename_rev_buf: Vec<u16>,
+    // long_filename_checksum: Option<u8>,
+    // long_filename_last_ordinal: Option<u8>,
     long_filename_buf: LongFilenameBuf,
 }
 
-impl<'a> DirIter<'a> {
-    pub fn new(reader: ClusterChainReader<'a>) -> Self {
+impl<R: Read> DirIter<R> {
+    pub fn new(reader: R) -> DirIter<R> {
         DirIter {
             reader,
+            // long_filename_rev_buf: Vec::new(),
+            // long_filename_checksum: None,
+            // long_filename_last_ordinal: None,
             long_filename_buf: Default::default(),
         }
     }
 
-    pub fn find_by_name(&mut self, name: &str) -> Option<DirEntry> {
-        self.find(|dir_entry| &dir_entry.name_string() == name)
+    /// inner function for iterator
+    fn next_impl(&mut self) -> anyhow::Result<Option<DirEntry>> {
+        let mut chunk = [0; 32];
+        if self.reader.read_exact(&mut chunk).is_err() {
+            // reading failed; nothing we can do here
+            return Ok(None);
+        }
+
+        // let Ok(dir_entry) = DirEntry::load(&chunk) else {
+        //     return self.next();
+        // };
+
+        let dir_entry = DirEntryWrapper::load(&chunk)
+            .map_err(|e| anyhow::anyhow!("failed to load dir entry: {e}"))?;
+
+        let mut dir_entry = match dir_entry {
+            DirEntryWrapper::Regular(dir_entry) => dir_entry,
+            DirEntryWrapper::LongName(long_name) => {
+                self.long_filename_buf.next(long_name).map_err(|e| {
+                    self.long_filename_buf.reset();
+                    anyhow::anyhow!("invalid long filename entry: {e}")
+                })?;
+
+                return self.next_impl();
+            }
+        };
+
+        if dir_entry.is_sentinel() {
+            return Ok(None);
+        }
+
+        if dir_entry.is_empty() {
+            return self.next_impl();
+        }
+
+        match self
+            .long_filename_buf
+            .get_buf(dir_entry.checksum())
+            .map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to get long filename for {}: {}",
+                    dir_entry.name_str().as_deref().unwrap_or("<invalid>"),
+                    e
+                )
+            })? {
+            Some(iter) => {
+                // attach long filename to dir_entry
+
+                let long_filename: String =
+                    char::decode_utf16(iter).filter_map(|x| x.ok()).collect();
+
+                dir_entry.set_long_name(long_filename);
+            }
+            None => {} // no long filename -> do nothing
+        }
+
+        self.long_filename_buf.reset();
+
+        Ok(Some(dir_entry))
     }
 }
 
-impl Iterator for DirIter<'_> {
+impl<R: Read> Iterator for DirIter<R> {
     type Item = DirEntry;
 
     fn next(&mut self) -> Option<Self::Item> {
-        fn next_impl(me: &mut DirIter<'_>) -> anyhow::Result<Option<DirEntry>> {
-            let offset = me.reader.current_offset();
-
-            let mut chunk = [0; 32];
-
-            if me.reader.read_exact(&mut chunk).is_err() {
-                // nothing we can do here since we might be in an invalid state after a partial read
-                anyhow::bail!("read failed");
-            }
-
-            let dir_entry = DirEntryWrapper::load(&chunk, offset)
-                .map_err(|e| anyhow::anyhow!("failed to load dir entry: {e}"))?;
-
-            let mut dir_entry = match dir_entry {
-                DirEntryWrapper::Regular(dir_entry) => dir_entry,
-                DirEntryWrapper::LongName(long_name) => {
-                    me.long_filename_buf.next(long_name).map_err(|e| {
-                        me.long_filename_buf.reset();
-                        anyhow::anyhow!("invalid long filename entry: {e}")
-                    })?;
-
-                    return next_impl(me);
-                }
-            };
-
-            if dir_entry.is_sentinel() {
-                return Ok(None);
-            }
-
-            if dir_entry.is_empty() {
-                return next_impl(me);
-            }
-
-            if let Some((iter, n_slots)) = me
-                .long_filename_buf
-                .get_buf(dir_entry.checksum)
-                .map_err(|e| {
-                    anyhow::anyhow!(
-                        "failed to get long filename for {}: {}",
-                        dir_entry.name_string(),
-                        e
-                    )
-                })?
-            {
-                // attach long filename to dir_entry
-
-                let long_filename: CompactString =
-                    char::decode_utf16(iter).filter_map(|x| x.ok()).collect();
-
-                dir_entry.set_long_name(long_filename, n_slots);
-            }
-
-            me.long_filename_buf.reset();
-
-            Ok(Some(dir_entry))
-        }
-
-        match next_impl(self) {
+        match self.next_impl() {
             Ok(x) => x,
             Err(e) => {
-                // print error message, try next
-                debug!("{}", e);
+                eprintln!("{}", e);
 
                 self.next()
             }
diff --git a/fat-bits/src/fat.rs b/fat-bits/src/fat.rs
index 2a33588..bc475dd 100644
--- a/fat-bits/src/fat.rs
+++ b/fat-bits/src/fat.rs
@@ -1,15 +1,10 @@
 use std::fmt::Display;
-use std::io::Write as _;
 use std::mem::MaybeUninit;
 use std::ops::RangeInclusive;
 
 use enum_dispatch::enum_dispatch;
-use log::debug;
 
 use crate::FatType;
-use crate::subslice::SubSliceMut;
-
-const FREE_ENTRY: u32 = 0;
 
 #[derive(Debug, thiserror::Error)]
 pub enum FatError {
@@ -24,24 +19,26 @@ pub enum FatError {
 }
 
 #[enum_dispatch]
-trait FatOps {
+pub trait Fatty {
     // get the next cluster
     // assumes the cluster is valid, i.e. allocated
     fn get_entry(&self, cluster: u32) -> u32;
-    fn set_entry(&mut self, cluster: u32, entry: u32);
 
-    fn valid_entries(&self) -> RangeInclusive<u32>;
-    fn reserved_entries(&self) -> RangeInclusive<u32>;
-    fn defective_entry(&self) -> u32;
-    fn reserved_eof_entries(&self) -> RangeInclusive<u32>;
-    fn eof_entry(&self) -> u32;
+    fn get_valid_clusters(&self) -> RangeInclusive<u32>;
+    fn get_reserved_clusters(&self) -> RangeInclusive<u32>;
+    fn get_defective_cluster(&self) -> u32;
+    fn get_reserved_eof_clusters(&self) -> RangeInclusive<u32>;
+    fn get_eof_cluster(&self) -> u32;
 
-    fn write_to_disk(&self, sub_slice: SubSliceMut) -> std::io::Result<()>;
+    fn count_free_clusters(&self) -> usize {
+        self.get_valid_clusters()
+            .map(|cluster| self.get_entry(cluster))
+            .filter(|&entry| entry == 0)
+            .count()
+    }
 }
 
-#[enum_dispatch(FatOps)]
-// others should never touch the inner FatNs directly, but instead go through the Fat type
-#[allow(private_interfaces)]
+#[enum_dispatch(Fatty)]
 pub enum Fat {
     Fat12(Fat12),
     Fat16(Fat16),
@@ -67,32 +64,24 @@ impl Fat {
         }
     }
 
-    pub fn fat_type(&self) -> FatType {
-        match self {
-            Fat::Fat12(_) => FatType::Fat12,
-            Fat::Fat16(_) => FatType::Fat16,
-            Fat::Fat32(_) => FatType::Fat32,
-        }
-    }
-
     pub fn get_next_cluster(&self, cluster: u32) -> Result<Option<u32>, FatError> {
-        if cluster == FREE_ENTRY {
+        if cluster == 0x000 {
             // can't get next cluster for free cluster
             return Err(FatError::FreeCluster);
         }
 
-        if self.reserved_entries().contains(&cluster) {
+        if self.get_reserved_clusters().contains(&cluster) {
             // can't get next cluster for reserved cluster
             return Err(FatError::ReservedCluster(cluster));
         }
 
         // defective cluster
-        if cluster == self.defective_entry() {
+        if cluster == self.get_defective_cluster() {
             // can't get next cluster for defective cluster
             return Err(FatError::DefectiveCluster);
         }
 
-        if self.reserved_eof_entries().contains(&cluster) {
+        if self.get_reserved_eof_clusters().contains(&cluster) {
             // Reserved and should not be used. May be interpreted as an allocated cluster and the
             // final cluster in the file (indicating end-of-file condition).
             //
@@ -104,117 +93,21 @@ impl Fat {
 
         let entry = self.get_entry(cluster);
 
-        if entry == FREE_ENTRY {
-            Ok(None)
-        } else if entry == self.eof_entry() {
-            Ok(None)
-        } else if self.valid_entries().contains(&entry) {
-            Ok(Some(entry))
-        } else if self.reserved_entries().contains(&entry) || entry == 1 {
-            Err(FatError::ReservedCluster(entry))
-        } else if entry == self.defective_entry() {
-            Err(FatError::DefectiveCluster)
-        } else {
-            unreachable!()
-        }
-    }
-
-    /// set the next cluster of `cluster` to either some `next_cluster` or EOF
-    ///
-    /// if `cluster` currently points to another cluster, that cluster MUST be the EOF and will be
-    /// freed
-    pub fn set_next_cluster(&mut self, cluster: u32, next_cluster: Option<u32>) {
-        assert!(self.valid_entries().contains(&cluster));
-
-        let cur_next_cluster = self.get_entry(cluster);
-
-        // can't be defective
-        assert_ne!(cur_next_cluster, self.defective_entry());
-
-        if self.valid_entries().contains(&cur_next_cluster) {
-            // cluster currently points to a valid cluster, so we free it
-
-            log::debug!("freeing chain beginning at {cluster}");
-            self.free_chain(cluster);
+        // interpret second reserved block as EOF here
+        if entry == self.get_eof_cluster() || self.get_reserved_eof_clusters().contains(&entry) {
+            return Ok(None);
         }
 
-        if let Some(next_cluster) = next_cluster {
-            assert!(self.valid_entries().contains(&next_cluster));
+        // entry should be in the valid cluster range here; otherwise something went wrong
+        if !self.get_valid_clusters().contains(&entry) {
+            return Err(FatError::InvalidEntry(entry));
         }
 
-        if let Some(next_cluster) = next_cluster {
-            log::debug!("setting {cluster} -> {next_cluster}");
-        } else {
-            log::debug!("setting {cluster} EOF");
-        }
-
-        self.set_entry(cluster, next_cluster.unwrap_or(self.eof_entry()));
-    }
-
-    /// free a cluster
-    ///
-    /// must be EOF
-    pub fn free_cluster(&mut self, cluster: u32) {
-        debug!("freeing cluster {cluster}");
-
-        let entry = self.get_entry(cluster);
-
-        if entry == FREE_ENTRY {
-            // nothing to be done here
-            debug!("cluster was already free");
-            return;
-        }
-
-        // can't be reserved or defective
-        // can't be pointing to another cluster (we'd orphan that one)
-        // use free_chain to free a chain of clusters iteratively
-        assert!(self.is_eof(entry));
-
-        self.set_entry(cluster, FREE_ENTRY);
-    }
-
-    /// free `first_cluster` and all following clusters
-    pub fn free_chain(&mut self, mut first_cluster: u32) {
-        debug!("freeing chaing at {first_cluster}");
-
-        loop {
-            let entry = self.get_entry(first_cluster);
-
-            // assert cluster either points to another cluster of is the EOF
-            assert!(self.valid_entries().contains(&entry) || self.is_eof(entry));
-
-            self.set_entry(first_cluster, FREE_ENTRY);
-
-            if self.valid_entries().contains(&entry) {
-                first_cluster = entry;
-            } else {
-                break;
-            }
-        }
-    }
-
-    pub fn count_free_clusters(&self) -> u32 {
-        self.valid_entries()
-            .map(|cluster| self.get_entry(cluster))
-            .filter(|&entry| entry == FREE_ENTRY)
-            .count() as u32
-    }
-
-    pub fn first_free_cluster(&self) -> Option<u32> {
-        self.valid_entries()
-            .find(|&cluster| self.get_entry(cluster) == FREE_ENTRY)
-    }
-
-    fn is_eof(&self, entry: u32) -> bool {
-        entry == self.eof_entry() || self.reserved_eof_entries().contains(&entry)
-    }
-
-    pub fn write_back(&self, sub_slice: SubSliceMut) -> std::io::Result<()> {
-        self.write_to_disk(sub_slice)
+        Ok(Some(entry))
     }
 }
 
-struct Fat12 {
+pub struct Fat12 {
     max: u32,
 
     next_sectors: Box<[u16]>,
@@ -225,7 +118,7 @@ impl Display for Fat12 {
         writeln!(f, "Fat 12 {{")?;
 
         for (i, &x) in self.next_sectors.iter().enumerate() {
-            if x != FREE_ENTRY as u16 {
+            if x != 0 {
                 writeln!(f, "    0x{:03X} -> 0x{:03X}", i, x)?;
             }
         }
@@ -251,10 +144,7 @@ impl Fat12 {
 
         // assume bytes.len() is multiple of 3
         // TODO: fix later
-        // assert_eq!(bytes.len() % 3, 0);
-        assert_eq!(max % 2, 0);
-
-        let bytes = &bytes[..next_sectors.len() / 2 * 3];
+        assert_eq!(bytes.len() % 3, 0);
 
         let (chunks, rem) = bytes.as_chunks::<3>();
 
@@ -288,7 +178,7 @@ impl Fat12 {
     }
 }
 
-impl FatOps for Fat12 {
+impl Fatty for Fat12 {
     fn get_entry(&self, cluster: u32) -> u32 {
         let cluster = cluster as usize;
         assert!(cluster < self.next_sectors.len());
@@ -296,74 +186,28 @@ impl FatOps for Fat12 {
         self.next_sectors[cluster] as u32
     }
 
-    fn set_entry(&mut self, cluster: u32, entry: u32) {
-        self.next_sectors[cluster as usize] = entry as u16;
-    }
-
-    fn valid_entries(&self) -> RangeInclusive<u32> {
+    fn get_valid_clusters(&self) -> RangeInclusive<u32> {
         2..=self.max
     }
 
-    fn reserved_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_clusters(&self) -> RangeInclusive<u32> {
         (self.max as u32 + 1)..=0xFF6
     }
 
-    fn defective_entry(&self) -> u32 {
+    fn get_defective_cluster(&self) -> u32 {
         0xFF7
     }
 
-    fn reserved_eof_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_eof_clusters(&self) -> RangeInclusive<u32> {
         0xFF8..=0xFFE
     }
 
-    fn eof_entry(&self) -> u32 {
+    fn get_eof_cluster(&self) -> u32 {
         0xFFF
     }
-
-    fn write_to_disk(&self, mut sub_slice: SubSliceMut) -> std::io::Result<()> {
-        assert!(2 * sub_slice.len() > 3 * self.next_sectors.len());
-
-        let mut iter = self.next_sectors.chunks_exact(2);
-
-        let mut buf: [u8; 3];
-
-        for chunk in &mut iter {
-            // first (even) entry gets truncated
-            // let first = u16::from_le_bytes(triple[..2].try_into().unwrap()) & 0xFFF;
-            // second (odd) entry gets shifted
-            // let second = u16::from_le_bytes(triple[1..].try_into().unwrap()) >> 4;
-
-            // assert!(idx + 1 < next_sectors.len());
-
-            // next_sectors[2 * idx] = first;
-            // next_sectors[2 * idx + 1] = second;
-
-            // sub_slice.write_all(&entry.to_le_bytes())?;
-
-            let first = chunk[0];
-            let second = chunk[1];
-
-            buf = [0; 3];
-
-            // buf[..2] |= &first.to_le_bytes();
-            buf[0] = first.to_le_bytes()[0];
-            buf[1] = first.to_le_bytes()[1] | (second << 4).to_le_bytes()[0];
-            buf[2] = (second << 4).to_le_bytes()[1];
-            sub_slice.write_all(&buf)?;
-        }
-
-        match iter.remainder() {
-            [] => {}
-            [x] => sub_slice.write_all(&x.to_le_bytes())?,
-
-            _ => unreachable!(),
-        }
-
-        Ok(())
-    }
 }
 
-struct Fat16 {
+pub struct Fat16 {
     max: u32,
 
     next_sectors: Box<[u16]>,
@@ -374,7 +218,7 @@ impl Display for Fat16 {
         writeln!(f, "Fat 16 {{")?;
 
         for (i, &x) in self.next_sectors.iter().enumerate() {
-            if x != FREE_ENTRY as u16 {
+            if x != 0 {
                 writeln!(f, "    0x{:03X} -> 0x{:03X}", i, x)?;
             }
         }
@@ -418,7 +262,7 @@ impl Fat16 {
     }
 }
 
-impl FatOps for Fat16 {
+impl Fatty for Fat16 {
     fn get_entry(&self, cluster: u32) -> u32 {
         let cluster = cluster as usize;
         assert!(cluster < self.next_sectors.len());
@@ -426,42 +270,28 @@ impl FatOps for Fat16 {
         self.next_sectors[cluster] as u32
     }
 
-    fn set_entry(&mut self, cluster: u32, entry: u32) {
-        self.next_sectors[cluster as usize] = entry as u16;
-    }
-
-    fn valid_entries(&self) -> RangeInclusive<u32> {
+    fn get_valid_clusters(&self) -> RangeInclusive<u32> {
         2..=self.max
     }
 
-    fn reserved_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_clusters(&self) -> RangeInclusive<u32> {
         (self.max as u32 + 1)..=0xFFF6
     }
 
-    fn defective_entry(&self) -> u32 {
+    fn get_defective_cluster(&self) -> u32 {
         0xFFF7
     }
 
-    fn reserved_eof_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_eof_clusters(&self) -> RangeInclusive<u32> {
         0xFFF8..=0xFFFE
     }
 
-    fn eof_entry(&self) -> u32 {
+    fn get_eof_cluster(&self) -> u32 {
         0xFFFF
     }
-
-    fn write_to_disk(&self, mut sub_slice: SubSliceMut) -> std::io::Result<()> {
-        assert_eq!(2 * sub_slice.len(), self.next_sectors.len());
-
-        for &entry in self.next_sectors.iter() {
-            sub_slice.write_all(&entry.to_le_bytes())?;
-        }
-
-        Ok(())
-    }
 }
 
-struct Fat32 {
+pub struct Fat32 {
     max: u32,
 
     next_sectors: Box<[u32]>,
@@ -472,7 +302,7 @@ impl Display for Fat32 {
         writeln!(f, "Fat 32 {{")?;
 
         for (i, &x) in self.next_sectors.iter().enumerate() {
-            if x != FREE_ENTRY {
+            if x != 0 {
                 writeln!(f, "    0x{:03X} -> 0x{:03X}", i, x)?;
             }
         }
@@ -516,7 +346,7 @@ impl Fat32 {
     }
 }
 
-impl FatOps for Fat32 {
+impl Fatty for Fat32 {
     fn get_entry(&self, cluster: u32) -> u32 {
         let cluster = cluster as usize;
         assert!(cluster < self.next_sectors.len());
@@ -524,37 +354,23 @@ impl FatOps for Fat32 {
         self.next_sectors[cluster] as u32
     }
 
-    fn set_entry(&mut self, cluster: u32, entry: u32) {
-        self.next_sectors[cluster as usize] = entry;
-    }
-
-    fn valid_entries(&self) -> RangeInclusive<u32> {
+    fn get_valid_clusters(&self) -> RangeInclusive<u32> {
         2..=self.max
     }
 
-    fn reserved_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_clusters(&self) -> RangeInclusive<u32> {
         (self.max + 1)..=0xFFFFFFF6
     }
 
-    fn defective_entry(&self) -> u32 {
+    fn get_defective_cluster(&self) -> u32 {
         0xFFFFFFF7
     }
 
-    fn reserved_eof_entries(&self) -> RangeInclusive<u32> {
+    fn get_reserved_eof_clusters(&self) -> RangeInclusive<u32> {
         0xFFFFFFF8..=0xFFFFFFFE
     }
 
-    fn eof_entry(&self) -> u32 {
+    fn get_eof_cluster(&self) -> u32 {
         0xFFFFFFFF
     }
-
-    fn write_to_disk(&self, mut sub_slice: SubSliceMut) -> std::io::Result<()> {
-        assert_eq!(4 * sub_slice.len(), self.next_sectors.len());
-
-        for &entry in self.next_sectors.iter() {
-            sub_slice.write_all(&entry.to_le_bytes())?;
-        }
-
-        Ok(())
-    }
 }
diff --git a/fat-bits/src/fs_info.rs b/fat-bits/src/fs_info.rs
index b8ba50f..f381652 100644
--- a/fat-bits/src/fs_info.rs
+++ b/fat-bits/src/fs_info.rs
@@ -40,12 +40,4 @@ impl FsInfo {
             next_free,
         })
     }
-
-    pub fn free_count(&self) -> u32 {
-        self.free_count
-    }
-
-    pub fn next_free(&self) -> Option<u32> {
-        Some(self.next_free)
-    }
 }
diff --git a/fat-bits/src/iter.rs b/fat-bits/src/iter.rs
index 6c2a9d9..8a6f775 100644
--- a/fat-bits/src/iter.rs
+++ b/fat-bits/src/iter.rs
@@ -1,94 +1,48 @@
-use std::io::{Read, Write};
+use std::io::Read;
 
-use log::debug;
-
-use crate::subslice::{SubSlice, SubSliceMut};
-use crate::{FatFs, FatType};
+use crate::FatFs;
+use crate::subslice::SubSlice;
+use crate::utils::replace;
 
 pub struct ClusterChainReader<'a> {
-    fat_fs: &'a FatFs,
-
-    sub_slice: SubSlice,
+    sub_slice: SubSlice<'a>,
 
     next_cluster: Option<u32>,
 }
 
 impl<'a> ClusterChainReader<'a> {
-    pub fn new(fat_fs: &'a FatFs, first_cluster: u32) -> Self {
+    pub fn new(fat_fs: &'a FatFs, first_cluster: u32) -> ClusterChainReader<'a> {
         let next_cluster = fat_fs.next_cluster(first_cluster).unwrap_or(None);
 
         let sub_slice = fat_fs.cluster_as_subslice(first_cluster);
 
         ClusterChainReader {
-            fat_fs,
             sub_slice,
             next_cluster,
         }
     }
 
-    pub fn root_dir_reader(fat_fs: &'a FatFs) -> Self {
-        match fat_fs.fat_type() {
-            FatType::Fat12 | FatType::Fat16 => {
-                // fixed root dir, so no need to chain
-                // get a single SubSlice for it and next_cluster is None
-
-                let sub_slice = fat_fs.root_dir_as_subslice();
-
-                ClusterChainReader {
-                    fat_fs,
-                    sub_slice,
-                    next_cluster: None,
-                }
-            }
-            FatType::Fat32 => {
-                // FAT is directory_like, so get a real chain reader
-
-                Self::new(fat_fs, fat_fs.bpb.root_cluster().unwrap())
-            }
-        }
-    }
-
-    fn move_to_next_cluster(&mut self) -> bool {
+    fn next_cluster(&mut self) -> bool {
         let Some(next_cluster) = self.next_cluster else {
             return false;
         };
 
-        self.next_cluster = self.fat_fs.next_cluster(next_cluster).unwrap_or(None);
-        self.sub_slice = self.fat_fs.cluster_as_subslice(next_cluster);
+        replace(&mut self.sub_slice, |sub_slice| {
+            let fat_fs = sub_slice.release();
+
+            self.next_cluster = fat_fs.next_cluster(next_cluster).unwrap_or(None);
+
+            fat_fs.cluster_as_subslice(next_cluster)
+        });
 
         true
     }
-
-    pub fn skip(&mut self, n: u64) -> u64 {
-        let mut bytes_to_skip = n;
-
-        while bytes_to_skip > self.sub_slice.len() as u64 {
-            bytes_to_skip -= self.sub_slice.len() as u64;
-            if !self.move_to_next_cluster() {
-                // ran out of bytes to seek
-                return n - bytes_to_skip;
-            }
-        }
-
-        if bytes_to_skip != 0 {
-            bytes_to_skip -= self.sub_slice.skip(bytes_to_skip as usize) as u64;
-        }
-
-        // n should absolutely be zero here
-        assert_eq!(bytes_to_skip, 0);
-
-        n
-    }
-
-    pub fn current_offset(&self) -> u64 {
-        self.sub_slice.offset()
-    }
 }
 
-impl Read for ClusterChainReader<'_> {
+impl<'a> Read for ClusterChainReader<'a> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         if self.sub_slice.is_empty() {
-            if !self.move_to_next_cluster() {
+            if !self.next_cluster() {
                 return Ok(0);
             }
         }
@@ -96,127 +50,3 @@ impl Read for ClusterChainReader<'_> {
         self.sub_slice.read(buf)
     }
 }
-
-pub struct ClusterChainWriter<'a> {
-    fat_fs: &'a mut FatFs,
-
-    sub_slice: SubSliceMut,
-
-    // next_cluster: Option<u32>,
-    cur_cluster: u32,
-}
-
-impl<'a> ClusterChainWriter<'a> {
-    pub fn new(fat_fs: &'a mut FatFs, first_cluster: u32) -> Self {
-        // let next_cluster = fat_fs.next_cluster(first_cluster).unwrap_or(None);
-
-        let sub_slice = fat_fs.cluster_as_subslice_mut(first_cluster);
-
-        ClusterChainWriter {
-            fat_fs,
-            sub_slice,
-            cur_cluster: first_cluster,
-        }
-    }
-
-    pub fn root_dir_writer(fat_fs: &'a mut FatFs) -> Self {
-        match fat_fs.fat_type() {
-            FatType::Fat12 | FatType::Fat16 => {
-                // fixed root dir, so no need to chain
-                // get a single SubSliceMut for it and next_cluster is None
-
-                let sub_slice = fat_fs.root_dir_as_subslice_mut();
-
-                ClusterChainWriter {
-                    fat_fs,
-                    sub_slice,
-                    cur_cluster: 0,
-                }
-            }
-            FatType::Fat32 => {
-                // FAT is directory_like, so get a real chain writer
-
-                Self::new(fat_fs, fat_fs.bpb.root_cluster().unwrap())
-            }
-        }
-    }
-
-    fn move_to_next_cluster(&mut self) -> bool {
-        // TODO: should allocate a new cluster here!
-        // let Some(next_cluster) = self.next_cluster else {
-        //     let Some(new_cluster) = self.fat_fs.alloc_cluster() else {
-        //         // cluster allocation failed
-        //         return false;
-        //     };
-
-        //     return false;
-        // };
-
-        let Some(next_cluster) = self
-            .fat_fs
-            .next_cluster(self.cur_cluster)
-            .map_err(|err| {
-                debug!("failed to get next cluster: {err}");
-                err
-            })
-            .unwrap_or(None)
-            .or_else(|| {
-                debug!("allocating new cluster");
-
-                self.fat_fs.alloc_cluster(Some(self.cur_cluster))
-            })
-        else {
-            debug!("failed to allocate next cluster");
-
-            return false;
-        };
-
-        debug!("next cluster: {next_cluster}");
-
-        self.fat_fs.cluster_as_subslice_mut(next_cluster);
-        self.cur_cluster = next_cluster;
-
-        true
-    }
-
-    pub fn skip(&mut self, n: u64) -> u64 {
-        let mut bytes_to_skip = n;
-
-        while bytes_to_skip > self.sub_slice.len() as u64 {
-            bytes_to_skip -= self.sub_slice.len() as u64;
-            if !self.move_to_next_cluster() {
-                // ran out of bytes to seek
-                return n - bytes_to_skip;
-            }
-        }
-
-        if bytes_to_skip != 0 {
-            bytes_to_skip -= self.sub_slice.skip(bytes_to_skip as usize) as u64;
-        }
-
-        // n should absolutely be zero here
-        assert_eq!(bytes_to_skip, 0);
-
-        n
-    }
-
-    pub fn current_offset(&self) -> u64 {
-        self.sub_slice.offset()
-    }
-}
-
-impl Write for ClusterChainWriter<'_> {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        if self.sub_slice.is_empty() {
-            if !(self.move_to_next_cluster()) {
-                return Ok(0);
-            }
-        }
-
-        self.sub_slice.write(buf)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        Ok(())
-    }
-}
diff --git a/fat-bits/src/lib.rs b/fat-bits/src/lib.rs
index 88092f7..f17275c 100644
--- a/fat-bits/src/lib.rs
+++ b/fat-bits/src/lib.rs
@@ -1,13 +1,9 @@
 use std::cell::RefCell;
-use std::fmt::Display;
+use std::io::{Read, Seek, SeekFrom, Write};
 use std::rc::Rc;
 
-use log::debug;
-
 use crate::dir::DirIter;
-use crate::fat::FatError;
-use crate::iter::ClusterChainReader;
-pub use crate::slice_like::SliceLike;
+use crate::fat::{FatError, Fatty};
 use crate::subslice::{SubSlice, SubSliceMut};
 
 pub mod bpb;
@@ -15,8 +11,7 @@ mod datetime;
 pub mod dir;
 pub mod fat;
 pub mod fs_info;
-pub mod iter;
-mod slice_like;
+mod iter;
 mod subslice;
 mod utils;
 
@@ -27,59 +22,84 @@ pub enum FatType {
     Fat32,
 }
 
-pub struct FatFs {
-    inner: Rc<RefCell<dyn SliceLike>>,
+pub trait SliceLike {
+    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()>;
 
-    // fat_offset: u64,
-    // fat_size: usize,
-    root_dir_offset: Option<u64>,
-    root_dir_size: usize,
-
-    pub data_offset: u64,
-    // data_size: usize,
-    bytes_per_cluster: usize,
-
-    bpb: bpb::Bpb,
-
-    fat: fat::Fat,
-
-    next_free: Option<u32>,
-    free_count: u32,
+    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()>;
 }
 
-impl Display for FatFs {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "{}", self.bpb)?;
-        writeln!(f, "")?;
-        writeln!(f, "{}", self.fat)?;
+impl SliceLike for &mut [u8] {
+    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
+        if offset as usize + buf.len() > self.len() {
+            return Err(std::io::Error::other(anyhow::anyhow!(
+                "reading {} bytes at offset {} is out of bounds for slice of len {}",
+                buf.len(),
+                offset,
+                self.len()
+            )));
+        }
+
+        buf.copy_from_slice(&self[offset as usize..][..buf.len()]);
+
+        Ok(())
+    }
+
+    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()> {
+        if offset as usize + bytes.len() > self.len() {
+            return Err(std::io::Error::other(anyhow::anyhow!(
+                "writing {} bytes at offset {} is out of bounds for slice of len {}",
+                bytes.len(),
+                offset,
+                self.len()
+            )));
+        }
+
+        self[offset as usize..][..bytes.len()].copy_from_slice(bytes);
 
         Ok(())
     }
 }
 
-unsafe impl Send for FatFs {}
+impl SliceLike for std::fs::File {
+    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
+        self.seek(SeekFrom::Start(offset))?;
 
-impl Drop for FatFs {
-    fn drop(&mut self) {
-        let fat_slice = SubSliceMut::new(
-            Rc::clone(&self.inner),
-            self.bpb.fat_offset(),
-            self.bpb.fat_len_bytes(),
-        );
+        self.read_exact(buf)?;
 
-        if let Err(err) = self.fat.write_back(fat_slice) {
-            debug!("writing FAT back to disk failed: {err}");
-        }
+        Ok(())
+    }
+
+    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()> {
+        self.seek(SeekFrom::Start(offset))?;
+
+        self.write_all(bytes)?;
+
+        Ok(())
     }
 }
 
-impl FatFs {
-    pub fn load<S>(data: S) -> anyhow::Result<FatFs>
-    where
-        S: SliceLike + Send + 'static,
-    {
-        let data = Rc::new(RefCell::new(data));
+#[allow(dead_code)]
+pub struct FatFs {
+    inner: Rc<RefCell<dyn SliceLike>>,
 
+    fat_offset: u64,
+    fat_size: usize,
+
+    root_dir_offset: Option<u64>,
+    root_dir_size: usize,
+
+    pub data_offset: u64,
+    data_size: usize,
+
+    bytes_per_cluster: usize,
+
+    bpb: bpb::Bpb,
+
+    fat: fat::Fat,
+}
+
+impl FatFs {
+    pub fn load(data: Rc<RefCell<dyn SliceLike>>) -> anyhow::Result<FatFs> {
         let mut bpb_bytes = [0; 512];
 
         data.borrow_mut().read_at_offset(0, &mut bpb_bytes)?;
@@ -108,177 +128,127 @@ impl FatFs {
         //     }
         // }
 
-        // let fat_offset = bpb.fat_offset();
-        // let fat_size = bpb.fat_len_bytes();
+        let fat_offset = bpb.fat_offset();
+        let fat_size = bpb.fat_len_bytes();
 
         let root_dir_offset = bpb.root_directory_offset();
         let root_dir_size = bpb.root_dir_len_bytes();
 
         let data_offset = bpb.data_offset();
-        // let data_size = bpb.data_len_bytes();
+        let data_size = bpb.data_len_bytes();
 
         let bytes_per_cluster = bpb.bytes_per_cluster();
 
-        let next_free = fat.first_free_cluster();
-        let free_count = fat.count_free_clusters();
-
         Ok(FatFs {
             inner: data,
-            // fat_offset,
-            // fat_size,
+            fat_offset,
+            fat_size,
             root_dir_offset,
             root_dir_size,
             data_offset,
-            // data_size,
+            data_size,
             bytes_per_cluster,
             bpb,
             fat,
-            next_free,
-            free_count,
         })
     }
 
-    pub fn fat_type(&self) -> FatType {
-        self.fat.fat_type()
+    pub fn bpb(&self) -> &bpb::Bpb {
+        &self.bpb
+    }
+
+    pub fn fat(&self) -> &fat::Fat {
+        &self.fat
     }
 
     /// byte offset of data cluster
-    fn data_cluster_to_offset(&self, cluster: u32) -> u64 {
+    pub fn data_cluster_to_offset(&self, cluster: u32) -> u64 {
         // assert!(cluster >= 2);
 
-        // assert!(self.fat.valid_entries().contains(&cluster));
+        assert!(self.fat().get_valid_clusters().contains(&cluster));
 
         self.data_offset + (cluster - 2) as u64 * self.bytes_per_cluster as u64
     }
 
-    pub fn free_clusters(&self) -> u32 {
-        // self.fat.count_free_clusters()
-        self.free_count
-    }
-
-    pub fn alloc_cluster(&mut self, prev_cluster: Option<u32>) -> Option<u32> {
-        let Some(new_cluster) = self.next_free else {
-            // no free cluster
-            return None;
-        };
-
-        debug!("next free cluster: {new_cluster}");
-
-        // set cluster as EOF
-        self.fat.set_next_cluster(new_cluster, None);
-
-        if let Some(prev_cluster) = prev_cluster {
-            self.fat.set_next_cluster(prev_cluster, Some(new_cluster));
-        }
-
-        // something went terribly wrong
-        assert_ne!(self.free_count, 0);
-
-        self.free_count -= 1;
-
-        // find next free cluster
-        self.next_free = self.fat.first_free_cluster();
-
-        Some(new_cluster)
-    }
-
-    pub fn dealloc_cluster(&mut self, cluster: u32) {
-        // assert cluster is actually valid
-        self.fat.free_cluster(cluster);
-
-        if self.next_free.is_none() || self.next_free.unwrap() > cluster {
-            self.next_free = Some(cluster);
-        }
-
-        self.free_count += 1;
-    }
-
-    pub fn bytes_per_sector(&self) -> u16 {
-        self.bpb.bytes_per_sector()
-    }
-
-    pub fn sectors_per_cluster(&self) -> u8 {
-        self.bpb.sectors_per_cluster()
-    }
-
-    pub fn root_cluster(&self) -> Option<u32> {
-        self.bpb.root_cluster()
-    }
-
     /// next data cluster or None is cluster is EOF
     ///
     /// giving an invalid cluster (free, reserved, or defective) returns an appropriate error
     pub fn next_cluster(&self, cluster: u32) -> Result<Option<u32>, FatError> {
-        self.fat.get_next_cluster(cluster)
+        self.fat().get_next_cluster(cluster)
     }
 
-    pub fn cluster_as_subslice(&self, cluster: u32) -> SubSlice {
-        if cluster == 0 {
-            // for cluster 0 simply return empty subslice
-            // this makes things a bit easier, since cluster 0 is used as a marker that a file/dir
-            // is empty
-
-            return SubSlice::new(self.inner.clone(), 0, 0);
-        }
-
+    pub fn cluster_as_subslice_mut(&mut self, cluster: u32) -> SubSliceMut<'_> {
         let offset = self.data_cluster_to_offset(cluster);
 
-        SubSlice::new(self.inner.clone(), offset, self.bytes_per_cluster)
+        SubSliceMut::new(self, offset, self.bytes_per_cluster)
     }
 
-    pub fn cluster_as_subslice_mut(&self, cluster: u32) -> SubSliceMut {
-        if cluster == 0 {
-            // for cluster 0 simply return empty subslice
-            // this makes things a bit easier, since cluster 0 is used as a marker that a file/dir
-            // is empty
-
-            return SubSliceMut::new(self.inner.clone(), 0, 0);
-        }
-
+    pub fn cluster_as_subslice(&self, cluster: u32) -> SubSlice<'_> {
         let offset = self.data_cluster_to_offset(cluster);
 
-        SubSliceMut::new(self.inner.clone(), offset, self.bytes_per_cluster)
+        SubSlice::new(self, offset, self.bytes_per_cluster)
     }
 
-    fn root_dir_as_subslice(&self) -> SubSlice {
-        SubSlice::new(self.inner.clone(), self.root_dir_offset.unwrap(), self.root_dir_size)
+    pub fn root_dir_bytes(&mut self) -> std::io::Result<Vec<u8>> {
+        if let Some(root_dir_offset) = self.root_dir_offset {
+            let mut data = Vec::new();
+
+            let mut subslice = SubSliceMut::new(self, root_dir_offset, self.root_dir_size);
+
+            subslice.read_to_end(&mut data)?;
+
+            return Ok(data);
+        }
+
+        let mut cluster = self.bpb().root_cluster().unwrap();
+
+        let mut data = vec![0; self.bytes_per_cluster];
+
+        let mut inner = self.inner.borrow_mut();
+
+        inner.read_at_offset(self.data_cluster_to_offset(cluster), &mut data)?;
+
+        while let Ok(Some(next_cluster)) = self.next_cluster(cluster) {
+            cluster = next_cluster;
+
+            inner.read_at_offset(self.data_cluster_to_offset(cluster), &mut data)?;
+        }
+
+        Ok(data)
     }
 
-    fn root_dir_as_subslice_mut(&self) -> SubSliceMut {
-        SubSliceMut::new(self.inner.clone(), self.root_dir_offset.unwrap(), self.root_dir_size)
-    }
-
-    fn chain_reader(&'_ self, first_cluster: u32) -> iter::ClusterChainReader<'_> {
+    fn chain_reader(&self, first_cluster: u32) -> impl Read {
         iter::ClusterChainReader::new(self, first_cluster)
     }
 
-    fn chain_writer(&'_ mut self, first_cluster: u32) -> iter::ClusterChainWriter<'_> {
-        iter::ClusterChainWriter::new(self, first_cluster)
+    pub fn root_dir_iter<'a>(&'a self) -> DirIter<Box<dyn Read + 'a>> {
+        // Box<dyn Iterator<Item = DirEntry> + '_>
+        // TODO: maybe wrap this in another RootDirIter enum, so we don't have to Box<dyn>
+
+        if let Some(root_dir_offset) = self.root_dir_offset {
+            // FAT12/FAT16
+
+            let sub_slice = SubSlice::new(self, root_dir_offset, self.root_dir_size);
+
+            return DirIter::new(Box::new(sub_slice));
+        }
+
+        // FAT32
+
+        // can't fail; we're in the FAT32 case
+        let root_cluster = self.bpb().root_cluster().unwrap();
+
+        let cluster_iter = iter::ClusterChainReader::new(self, root_cluster);
+
+        DirIter::new(Box::new(cluster_iter))
     }
 
-    pub fn root_dir_iter<'a>(&self) -> DirIter<'_> {
-        let reader = ClusterChainReader::root_dir_reader(self);
+    pub fn dir_iter<'a>(&'a self, first_cluster: u32) -> DirIter<Box<dyn Read + 'a>> {
+        // TODO: return type must match root_dir_iter
+        // if the Box<dyn> is changed there, update here as well
 
-        DirIter::new(reader)
-    }
-
-    pub fn dir_iter<'a>(&self, first_cluster: u32) -> DirIter<'_> {
         let cluster_iter = self.chain_reader(first_cluster);
 
-        DirIter::new(cluster_iter)
-    }
-
-    pub fn file_reader(&self, first_cluster: u32) -> iter::ClusterChainReader<'_> {
-        // TODO: needs to take file size into account
-        assert!(first_cluster >= 2);
-
-        self.chain_reader(first_cluster)
-    }
-
-    pub fn file_writer(&mut self, first_cluster: u32) -> iter::ClusterChainWriter<'_> {
-        // TODO: needs to take file size into account
-        assert!(first_cluster >= 2);
-
-        self.chain_writer(first_cluster)
+        DirIter::new(Box::new(cluster_iter))
     }
 }
diff --git a/fat-bits/src/slice_like.rs b/fat-bits/src/slice_like.rs
deleted file mode 100644
index 8f72df8..0000000
--- a/fat-bits/src/slice_like.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use std::fs::File;
-use std::io::{Read as _, Seek as _, SeekFrom, Write as _};
-
-pub trait SliceLike {
-    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()>;
-
-    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()>;
-}
-
-impl SliceLike for &mut [u8] {
-    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
-        if offset as usize + buf.len() > self.len() {
-            return Err(std::io::Error::other(anyhow::anyhow!(
-                "reading {} bytes at offset {} is out of bounds for slice of len {}",
-                buf.len(),
-                offset,
-                self.len()
-            )));
-        }
-
-        buf.copy_from_slice(&self[offset as usize..][..buf.len()]);
-
-        Ok(())
-    }
-
-    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()> {
-        if offset as usize + bytes.len() > self.len() {
-            return Err(std::io::Error::other(anyhow::anyhow!(
-                "writing {} bytes at offset {} is out of bounds for slice of len {}",
-                bytes.len(),
-                offset,
-                self.len()
-            )));
-        }
-
-        self[offset as usize..][..bytes.len()].copy_from_slice(bytes);
-
-        Ok(())
-    }
-}
-
-impl SliceLike for File {
-    fn read_at_offset(&mut self, offset: u64, buf: &mut [u8]) -> std::io::Result<()> {
-        self.seek(SeekFrom::Start(offset))?;
-
-        self.read_exact(buf)?;
-
-        Ok(())
-    }
-
-    fn write_at_offset(&mut self, offset: u64, bytes: &[u8]) -> std::io::Result<()> {
-        self.seek(SeekFrom::Start(offset))?;
-
-        self.write_all(bytes)?;
-
-        Ok(())
-    }
-}
diff --git a/fat-bits/src/subslice.rs b/fat-bits/src/subslice.rs
index 3875d7b..a710974 100644
--- a/fat-bits/src/subslice.rs
+++ b/fat-bits/src/subslice.rs
@@ -1,18 +1,16 @@
-use std::cell::RefCell;
 use std::fmt::Debug;
 use std::io::{Read, Write};
-use std::rc::Rc;
 
-use crate::SliceLike;
+use crate::FatFs;
 
-pub struct SubSlice {
-    data: Rc<RefCell<dyn SliceLike>>,
+pub struct SubSliceMut<'a> {
+    fat_fs: &'a mut FatFs,
 
     offset: u64,
     len: usize,
 }
 
-impl Debug for SubSlice {
+impl Debug for SubSliceMut<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("SubSliceMut")
             .field("offset", &self.offset)
@@ -21,15 +19,17 @@ impl Debug for SubSlice {
     }
 }
 
-impl<'a> SubSlice {
-    pub fn new(data: Rc<RefCell<dyn SliceLike>>, offset: u64, len: usize) -> SubSlice {
-        SubSlice { data, offset, len }
-    }
-
-    pub fn offset(&self) -> u64 {
-        self.offset
+impl SubSliceMut<'_> {
+    pub fn new(fat_fs: &mut FatFs, offset: u64, len: usize) -> SubSliceMut<'_> {
+        SubSliceMut {
+            fat_fs,
+            offset,
+            len,
+        }
     }
+}
 
+impl SubSliceMut<'_> {
     pub fn len(&self) -> usize {
         self.len
     }
@@ -37,22 +37,14 @@ impl<'a> SubSlice {
     pub fn is_empty(&self) -> bool {
         self.len() == 0
     }
-
-    pub fn skip(&mut self, n: usize) -> usize {
-        let n = n.min(self.len());
-
-        self.offset += n as u64;
-        self.len -= n;
-
-        n
-    }
 }
 
-impl Read for SubSlice {
+impl Read for SubSliceMut<'_> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let bytes_to_read = self.len.min(buf.len());
 
-        self.data
+        self.fat_fs
+            .inner
             .borrow_mut()
             .read_at_offset(self.offset, &mut buf[..bytes_to_read])?;
 
@@ -63,72 +55,12 @@ impl Read for SubSlice {
     }
 }
 
-pub struct SubSliceMut {
-    // fat_fs: &'a FatFs,
-    data: Rc<RefCell<dyn SliceLike>>,
-
-    offset: u64,
-    len: usize,
-}
-
-impl Debug for SubSliceMut {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SubSliceMut")
-            .field("offset", &self.offset)
-            .field("len", &self.len)
-            .finish()
-    }
-}
-
-impl SubSliceMut {
-    pub fn new(data: Rc<RefCell<dyn SliceLike>>, offset: u64, len: usize) -> SubSliceMut {
-        SubSliceMut { data, offset, len }
-    }
-}
-
-impl<'a> SubSliceMut {
-    pub fn offset(&self) -> u64 {
-        self.offset
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn skip(&mut self, n: usize) -> usize {
-        let n = n.min(self.len());
-
-        self.offset += n as u64;
-        self.len -= n;
-
-        n
-    }
-}
-
-impl Read for SubSliceMut {
-    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-        let bytes_to_read = self.len.min(buf.len());
-
-        self.data
-            .borrow_mut()
-            .read_at_offset(self.offset, &mut buf[..bytes_to_read])?;
-
-        self.offset += bytes_to_read as u64;
-        self.len -= bytes_to_read;
-
-        Ok(bytes_to_read)
-    }
-}
-
-impl Write for SubSliceMut {
+impl Write for SubSliceMut<'_> {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         let bytes_to_write = self.len.min(buf.len());
 
-        self.data
+        self.fat_fs
+            .inner
             .borrow_mut()
             .write_at_offset(self.offset, &buf[..bytes_to_write])?;
 
@@ -142,3 +74,67 @@ impl Write for SubSliceMut {
         Ok(())
     }
 }
+
+pub struct SubSlice<'a> {
+    fat_fs: &'a FatFs,
+
+    offset: u64,
+    len: usize,
+}
+
+impl Debug for SubSlice<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SubSliceMut")
+            .field("offset", &self.offset)
+            .field("len", &self.len)
+            .finish()
+    }
+}
+
+impl SubSlice<'_> {
+    pub fn new(fat_fs: &FatFs, offset: u64, len: usize) -> SubSlice<'_> {
+        SubSlice {
+            fat_fs,
+            offset,
+            len,
+        }
+    }
+
+    pub fn fat_fs(&self) -> &FatFs {
+        self.fat_fs
+    }
+
+    pub fn fat_fs_mut(&self) -> &FatFs {
+        self.fat_fs
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    pub fn len(&self) -> usize {
+        self.len
+    }
+}
+
+impl<'a> SubSlice<'a> {
+    /// releases the inner &FatFs, consuming self in the process
+    pub fn release(self) -> &'a FatFs {
+        self.fat_fs
+    }
+}
+
+impl Read for SubSlice<'_> {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let bytes_to_read = self.len.min(buf.len());
+
+        self.fat_fs
+            .inner
+            .borrow_mut()
+            .read_at_offset(self.offset, &mut buf[..bytes_to_read])?;
+
+        self.offset += bytes_to_read as u64;
+        self.len -= bytes_to_read;
+
+        Ok(bytes_to_read)
+    }
+}
diff --git a/fat-bits/src/utils.rs b/fat-bits/src/utils.rs
index 1e20e9d..0fe9834 100644
--- a/fat-bits/src/utils.rs
+++ b/fat-bits/src/utils.rs
@@ -3,9 +3,24 @@ pub fn load_u16_le(bytes: &[u8]) -> u16 {
 
     u16::from_le_bytes(bytes.try_into().unwrap())
 }
-
 pub fn load_u32_le(bytes: &[u8]) -> u32 {
     assert_eq!(bytes.len(), 4);
 
     u32::from_le_bytes(bytes.try_into().unwrap())
 }
+
+/// replace the value at x with f(x)
+///
+/// SAFETY:
+/// should be safe, I guess? MIRI didn't complain about it
+pub fn replace<T>(x: &mut T, f: impl FnOnce(T) -> T) {
+    unsafe {
+        let x_ptr = x as *mut T;
+
+        let old_x = std::ptr::read(x_ptr);
+
+        let new_x = f(old_x);
+
+        std::ptr::write(x_ptr, new_x);
+    }
+}
diff --git a/fat-dump/src/main.rs b/fat-dump/src/main.rs
index 90b5cb3..b2fe7c3 100644
--- a/fat-dump/src/main.rs
+++ b/fat-dump/src/main.rs
@@ -1,5 +1,9 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
 use fat_bits::FatFs;
-use fat_bits::dir::DirEntry;
+use fat_bits::dir::{DirEntry, DirIter};
+use fat_bits::fat::Fatty as _;
 
 pub fn main() -> anyhow::Result<()> {
     let args = std::env::args();
@@ -18,20 +22,18 @@ pub fn main() -> anyhow::Result<()> {
 
     // println!("{}", bpb);
 
-    let fat_fs = FatFs::load(file)?;
+    let fat_fs = FatFs::load(Rc::new(RefCell::new(file)))?;
 
-    // println!("{}", fat_fs.bpb());
-    // println!();
-    // println!("{}", fat_fs.fat());
-
-    println!("{}", fat_fs);
+    println!("{}", fat_fs.bpb());
+    println!();
+    println!("{}", fat_fs.fat());
     println!();
     println!(
         "free clusters: {} ({} bytes)",
-        fat_fs.free_clusters(),
-        fat_fs.free_clusters() as usize
-            * fat_fs.bytes_per_sector() as usize
-            * fat_fs.sectors_per_cluster() as usize
+        fat_fs.fat().count_free_clusters(),
+        fat_fs.fat().count_free_clusters()
+            * fat_fs.bpb().bytes_per_sector() as usize
+            * fat_fs.bpb().sectors_per_cluster() as usize
     );
 
     println!();
diff --git a/fat-fuse/Cargo.toml b/fat-fuse/Cargo.toml
index 9cf4698..ceebf15 100644
--- a/fat-fuse/Cargo.toml
+++ b/fat-fuse/Cargo.toml
@@ -5,20 +5,10 @@ edition = "2024"
 
 [dependencies]
 anyhow = "1.0.98"
-bitflags = "2.9.1"
-chrono = { version = "0.4.41", default-features = false, features = [
-    "alloc",
-    "clock",
-    "std",
-] }
-compact_string = "0.1.0"
+chrono = { version = "0.4.41", default-features = false, features = ["alloc", "clock", "std"] }
 fat-bits = { version = "0.1.0", path = "../fat-bits" }
 fuser = "0.15.1"
-fxhash = "0.2.1"
 libc = "0.2.174"
 log = "0.4.27"
-rand = { version = "0.9.2", default-features = false, features = [
-    "os_rng",
-    "small_rng",
-] }
+rand = { version = "0.9.2", default-features = false, features = ["os_rng", "small_rng"] }
 thiserror = "2.0.12"
diff --git a/fat-fuse/src/fuse.rs b/fat-fuse/src/fuse.rs
index 1df0e03..6168950 100644
--- a/fat-fuse/src/fuse.rs
+++ b/fat-fuse/src/fuse.rs
@@ -1,53 +1,11 @@
 use std::ffi::c_int;
-use std::io::{Read, Write};
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
-use bitflags::bitflags;
-use fat_bits::dir::DirEntry;
-use fuser::{FileType, Filesystem};
-use libc::{EACCES, EBADF, EINVAL, EIO, EISDIR, ENOENT, ENOSYS, ENOTDIR};
-use log::{debug, error};
+use fuser::Filesystem;
+use libc::{EIO, ENOENT, ENOSYS, ENOTDIR, EPERM};
+use log::{debug, warn};
 
 use crate::FatFuse;
-use crate::inode::InodeRef;
-
-const TTL: Duration = Duration::from_secs(1);
-
-bitflags! {
-    #[derive(Debug)]
-    struct OpenFlags: i32 {
-        const ReadOnly = libc::O_RDONLY;
-        const WriteOnly = libc::O_WRONLY;
-        const ReadWrite = libc::O_RDWR;
-
-        const Read = libc::O_RDONLY | libc::O_RDWR;
-        const Write = libc::O_WRONLY | libc::O_RDWR;
-
-        const Append = libc::O_APPEND;
-        const Create = libc::O_CREAT;
-        const Exclusive = libc::O_EXCL;
-        const Truncate = libc::O_TRUNC;
-
-        const _ = !0;
-    }
-}
-
-fn get_inode_by_fh_or_ino(fat_fuse: &FatFuse, fh: Option<u64>, ino: u64) -> Result<&InodeRef, i32> {
-    fh.map(|fh| {
-        let inode = fat_fuse.get_inode_by_fh(fh).ok_or(EBADF)?;
-
-        let found_ino = inode.borrow().ino();
-
-        if found_ino != ino {
-            debug!("inode associated with fh {} has ino {}, but expected {ino}", fh, found_ino);
-
-            return Err(EBADF);
-        }
-
-        Ok(inode)
-    })
-    .unwrap_or_else(|| fat_fuse.get_inode(ino).ok_or(ENOENT))
-}
 
 impl Filesystem for FatFuse {
     fn init(
@@ -58,18 +16,7 @@ impl Filesystem for FatFuse {
         Ok(())
     }
 
-    fn destroy(&mut self) {
-        debug!("inode_table: {}", self.inode_table.len());
-
-        debug!("ino_by_first_cluster: {}", self.ino_by_first_cluster.len());
-        for (&first_cluster, &ino) in self.ino_by_first_cluster.iter() {
-            debug!("{} -> {}", first_cluster, ino);
-        }
-
-        debug!("ino_by_fh: {}", self.ino_by_fh.len());
-
-        debug!("ino_by_path: {}", self.ino_by_path.len());
-    }
+    fn destroy(&mut self) {}
 
     fn lookup(
         &mut self,
@@ -78,72 +25,38 @@ impl Filesystem for FatFuse {
         name: &std::ffi::OsStr,
         reply: fuser::ReplyEntry,
     ) {
-        let Some(name) = name.to_str() else {
-            // TODO: add proper handling of non-utf8 strings
-            debug!("cannot convert OsStr {:?} to str", name);
+        // warn!("[Not Implemented] lookup(parent: {:#x?}, name {:?})", parent, name);
+        // reply.error(ENOSYS);
+
+        let parent_inode = if let Some(inode) = self.get_inode(parent) {
+            inode
+        } else {
+            // parent inode does not exist
+            // TODO: how can we make sure this does not exist?
+            // panic?
+            reply.error(EIO);
 
-            reply.error(EINVAL);
             return;
         };
 
-        debug!("looking up file {} with parent ino {}", name, parent);
-
-        let Some(parent_inode) = self.get_inode(parent).cloned() else {
-            // parent inode does not exist
-            // TODO: how can we make sure this does not happed?
-            // TODO: panic?
-            debug!("could not find inode for parent ino {}", parent);
+        let Ok(dir_iter) = parent_inode.dir_iter(&self.fat_fs) else {
+            reply.error(ENOTDIR);
+            return;
+        };
 
+        let Some(dir_entry) =
+            dir_iter.find(|dir_entry| dir_entry.name_str().as_deref() == Some(""))
+        else {
             reply.error(ENOENT);
             return;
         };
 
-        let parent_inode = parent_inode.borrow();
+        reply.entry(&Duration::from_secs(1), attr, generation);
 
-        let dir_entry: DirEntry = match parent_inode.find_child_by_name(&self.fat_fs, name) {
-            Ok(dir_entry) => dir_entry,
-            Err(err) => {
-                debug!("error: {}", err);
-                reply.error(err);
-
-                return;
-            }
-        };
-
-        let inode = self.get_or_make_inode(&dir_entry, &parent_inode);
-
-        let mut inode = inode.borrow_mut();
-
-        let attr = inode.file_attr();
-        let generation = inode.generation();
-
-        debug!("attr: {attr:?}");
-
-        reply.entry(&TTL, &attr, generation as u64);
-
-        inode.inc_ref_count();
+        todo!();
     }
 
-    fn forget(&mut self, _req: &fuser::Request<'_>, ino: u64, nlookup: u64) {
-        debug!("forgetting ino {} ({} times)", ino, nlookup);
-
-        let Some(inode) = self.get_inode(ino).cloned() else {
-            debug!("tried to forget {} refs of inode {}, but was not found", ino, nlookup);
-
-            return;
-        };
-
-        let mut inode_ref = inode.borrow_mut();
-
-        if inode_ref.dec_ref_count(nlookup) == 0 {
-            debug!("dropping inode {}", inode_ref.ino());
-
-            drop(inode_ref);
-
-            // no more references, drop inode
-            self.drop_inode(inode);
-        }
-    }
+    fn forget(&mut self, _req: &fuser::Request<'_>, _ino: u64, _nlookup: u64) {}
 
     fn getattr(
         &mut self,
@@ -152,89 +65,34 @@ impl Filesystem for FatFuse {
         fh: Option<u64>,
         reply: fuser::ReplyAttr,
     ) {
-        let inode = match get_inode_by_fh_or_ino(self, fh, ino) {
-            Ok(inode) => inode,
-            Err(err) => {
-                reply.error(err);
-                return;
-            }
-        };
-
-        let mut inode = inode.borrow_mut();
-
-        let attr = inode.file_attr();
-
-        inode.update_atime(SystemTime::now());
-        if let Err(err) = inode.write_back(&self.fat_fs) {
-            debug!("error while writing back inode: {err}");
-
-            reply.error(EIO);
-            return;
-        }
-
-        debug!("attr: {attr:?}");
-
-        reply.attr(&TTL, &attr);
+        warn!("[Not Implemented] getattr(ino: {:#x?}, fh: {:#x?})", ino, fh);
+        reply.error(ENOSYS);
     }
 
     fn setattr(
         &mut self,
         _req: &fuser::Request<'_>,
         ino: u64,
-        _mode: Option<u32>,
-        _uid: Option<u32>,
-        _gid: Option<u32>,
+        mode: Option<u32>,
+        uid: Option<u32>,
+        gid: Option<u32>,
         size: Option<u64>,
-        atime: Option<fuser::TimeOrNow>,
-        mtime: Option<fuser::TimeOrNow>,
+        _atime: Option<fuser::TimeOrNow>,
+        _mtime: Option<fuser::TimeOrNow>,
         _ctime: Option<std::time::SystemTime>,
         fh: Option<u64>,
         _crtime: Option<std::time::SystemTime>,
         _chgtime: Option<std::time::SystemTime>,
         _bkuptime: Option<std::time::SystemTime>,
-        _flags: Option<u32>,
+        flags: Option<u32>,
         reply: fuser::ReplyAttr,
     ) {
-        let inode = match get_inode_by_fh_or_ino(self, fh, ino) {
-            Ok(inode) => inode,
-            Err(err) => {
-                reply.error(err);
-                return;
-            }
-        };
-
-        let mut inode = inode.borrow_mut();
-
-        if let Some(new_size) = size {
-            inode.update_size(new_size);
-        }
-
-        if let Some(atime) = atime {
-            let atime = match atime {
-                fuser::TimeOrNow::SpecificTime(system_time) => system_time,
-                fuser::TimeOrNow::Now => SystemTime::now(),
-            };
-
-            inode.update_atime(atime);
-        }
-
-        if let Some(mtime) = mtime {
-            let mtime = match mtime {
-                fuser::TimeOrNow::SpecificTime(system_time) => system_time,
-                fuser::TimeOrNow::Now => SystemTime::now(),
-            };
-
-            inode.update_mtime(mtime);
-        }
-
-        if let Err(err) = inode.write_back(&self.fat_fs) {
-            debug!("writing back inode failed: {err}");
-
-            reply.error(EIO);
-            return;
-        }
-
-        reply.attr(&TTL, &inode.file_attr());
+        debug!(
+            "[Not Implemented] setattr(ino: {:#x?}, mode: {:?}, uid: {:?}, \
+            gid: {:?}, size: {:?}, fh: {:?}, flags: {:?})",
+            ino, mode, uid, gid, size, fh, flags
+        );
+        reply.error(ENOSYS);
     }
 
     fn readlink(&mut self, _req: &fuser::Request<'_>, ino: u64, reply: fuser::ReplyData) {
@@ -294,39 +152,23 @@ impl Filesystem for FatFuse {
         name: &std::ffi::OsStr,
         reply: fuser::ReplyEmpty,
     ) {
-        let Some(name) = name.to_str() else {
-            // TODO: add proper handling of non-utf8 strings
-            debug!("cannot convert OsStr {:?} to str", name);
+        debug!("[Not Implemented] rmdir(parent: {:#x?}, name: {:?})", parent, name,);
+        reply.error(ENOSYS);
+    }
 
-            reply.error(EINVAL);
-            return;
-        };
-
-        let Some(parent_inode) = self.get_inode(parent) else {
-            debug!("parent inode {parent} does not exist");
-
-            reply.error(ENOENT);
-            return;
-        };
-
-        let dir_entry = match parent_inode.borrow().find_child_by_name(&self.fat_fs, name) {
-            Ok(dir_entry) => dir_entry,
-            Err(err) => {
-                debug!("parent inode {parent} has no child {name}");
-
-                reply.error(err);
-                return;
-            }
-        };
-
-        if let Err(err) = dir_entry.erase(&self.fat_fs) {
-            debug!("error while erasing DirEntry: {err}");
-
-            reply.error(EIO);
-            return;
-        }
-
-        reply.ok();
+    fn symlink(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        parent: u64,
+        link_name: &std::ffi::OsStr,
+        target: &std::path::Path,
+        reply: fuser::ReplyEntry,
+    ) {
+        debug!(
+            "[Not Implemented] symlink(parent: {:#x?}, link_name: {:?}, target: {:?})",
+            parent, link_name, target,
+        );
+        reply.error(EPERM);
     }
 
     fn rename(
@@ -347,53 +189,23 @@ impl Filesystem for FatFuse {
         reply.error(ENOSYS);
     }
 
-    fn open(&mut self, _req: &fuser::Request<'_>, ino: u64, flags: i32, reply: fuser::ReplyOpen) {
-        if !self.inode_table.contains_key(&ino) {
-            reply.error(ENOENT);
-            return;
-        }
+    fn link(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        newparent: u64,
+        newname: &std::ffi::OsStr,
+        reply: fuser::ReplyEntry,
+    ) {
+        debug!(
+            "[Not Implemented] link(ino: {:#x?}, newparent: {:#x?}, newname: {:?})",
+            ino, newparent, newname
+        );
+        reply.error(EPERM);
+    }
 
-        let flags = OpenFlags::from_bits_truncate(flags);
-
-        debug!("flags: {flags:?}");
-
-        let Some(inode) = self.get_inode(ino).cloned() else {
-            debug!("inode {ino} not found");
-
-            reply.error(ENOENT);
-            return;
-        };
-
-        let mut inode = inode.borrow_mut();
-
-        if flags.intersects(OpenFlags::Write) && inode.is_read_only() {
-            debug!("tried to open read-only inode {ino} with write access");
-
-            reply.error(EACCES);
-            return;
-        }
-
-        let fh = self.next_fh();
-
-        if let Some(old_ino) = self.ino_by_fh.insert(fh, ino) {
-            debug!("fh {} was associated with ino {}, now with ino {}", fh, old_ino, ino);
-        }
-
-        debug!("opened inode {}: fh {}", ino, fh);
-
-        if flags.contains(OpenFlags::Truncate) {
-            inode.update_size(0);
-            inode.update_mtime(SystemTime::now());
-
-            if let Err(err) = inode.write_back(&self.fat_fs) {
-                debug!("writing back inode failed: {err}");
-
-                reply.error(EIO);
-                return;
-            }
-        }
-
-        reply.opened(fh, 0);
+    fn open(&mut self, _req: &fuser::Request<'_>, _ino: u64, _flags: i32, reply: fuser::ReplyOpen) {
+        reply.opened(0, 0);
     }
 
     fn read(
@@ -402,102 +214,17 @@ impl Filesystem for FatFuse {
         ino: u64,
         fh: u64,
         offset: i64,
-        mut size: u32,
-        _flags: i32,
-        _lock_owner: Option<u64>,
+        size: u32,
+        flags: i32,
+        lock_owner: Option<u64>,
         reply: fuser::ReplyData,
     ) {
-        debug!("trying to read {size} bytes at offset {offset} from inode {ino} (fh: {fh})");
-
-        if offset < 0 {
-            debug!("tried to read with negative offset {offset}");
-
-            reply.error(EINVAL);
-            return;
-        }
-
-        let offset = offset as u64;
-
-        let Some(inode) = self.get_inode_by_fh(fh) else {
-            debug!("fh {fh} is not associated by any inode");
-
-            reply.error(EBADF);
-            return;
-        };
-
-        let mut inode = inode.borrow_mut();
-
-        if inode.ino() != ino {
-            debug!("fh {fh} is associated with inode {} instead of {ino}", inode.ino());
-
-            reply.error(EINVAL);
-            return;
-        }
-
-        if !inode.is_file() {
-            debug!("tried to use read on directory {ino}");
-
-            reply.error(EISDIR);
-            return;
-        }
-
-        let file_size = inode.size();
-
-        debug!("file_size: {}", file_size);
-
-        if offset > file_size {
-            debug!("tried to read after EOF");
-
-            // offset is beyond file size, nothing to do here, just bail
-            reply.data(&[]);
-            return;
-        }
-
-        if offset + size as u64 > file_size {
-            // tried to read beyond end of file, truncate size so we don't overflow
-            debug!(
-                "tried to read {size} bytes at offset {offset} from inode {ino}, but size is only {file_size}"
-            );
-
-            size = (file_size - offset) as u32;
-
-            debug!("truncated read request size to {size}");
-        }
-
-        let mut reader = match inode.file_reader(&self.fat_fs) {
-            Ok(reader) => reader,
-            Err(err) => {
-                reply.error(err);
-                return;
-            }
-        };
-
-        if reader.skip(offset) != offset {
-            // this should not happen as we checked for valid bounds earlier
-            reply.error(EIO);
-            return;
-        }
-
-        let mut buf = vec![0; size as usize];
-
-        let bytes_read = match reader.read(&mut buf) {
-            Ok(n) => n,
-            Err(err) => {
-                error!("error while reading: {err}");
-
-                reply.error(EIO);
-                return;
-            }
-        };
-        if bytes_read != size as usize {
-            debug!("expected to read {size} bytes, but only read {bytes_read}");
-        }
-
-        inode.update_atime(SystemTime::now());
-
-        reply.data(&buf[..bytes_read]);
-
-        // TODO: update access time
+        warn!(
+            "[Not Implemented] read(ino: {:#x?}, fh: {}, offset: {}, size: {}, \
+            flags: {:#x?}, lock_owner: {:?})",
+            ino, fh, offset, size, flags, lock_owner
+        );
+        reply.error(ENOSYS);
     }
 
     fn write(
@@ -507,110 +234,23 @@ impl Filesystem for FatFuse {
         fh: u64,
         offset: i64,
         data: &[u8],
-        _write_flags: u32,
-        _flags: i32,
-        _lock_owner: Option<u64>,
+        write_flags: u32,
+        flags: i32,
+        lock_owner: Option<u64>,
         reply: fuser::ReplyWrite,
     ) {
-        debug!("new write request: ino={ino} fh={fh} offset={offset} data={data:?}");
-
-        if offset < 0 {
-            debug!("tried to write with negative offset {offset}");
-
-            reply.error(EINVAL);
-            return;
-        }
-
-        let offset = offset as u64;
-
-        let Some(inode) = self.get_inode_by_fh(fh).cloned() else {
-            debug!("no inode associated with fh {fh} (given ino: {ino}");
-
-            reply.error(EBADF);
-            return;
-        };
-
-        // borrow mut so we can potentially update the file size later
-        let mut inode = inode.borrow_mut();
-
-        if inode.is_read_only() {
-            reply.error(EBADF);
-            return;
-        }
-
-        if inode.ino() != ino {
-            debug!("fh {fh} points to ino {}, but ino {ino} was given", inode.ino());
-
-            reply.error(EINVAL);
-            return;
-        }
-
-        if !inode.is_file() {
-            debug!("tried to use read on directory {ino}");
-
-            reply.error(EISDIR);
-            return;
-        }
-
-        let mut writer = match inode.file_writer(&mut self.fat_fs) {
-            Ok(writer) => writer,
-            Err(err) => {
-                reply.error(err);
-                return;
-            }
-        };
-
-        let cur_offset = writer.skip(offset);
-
-        // can't seek more than we requested
-        assert!(cur_offset <= offset);
-
-        let mut bytes_written = 0;
-
-        if cur_offset < offset {
-            // tried to set offset beyond EOF
-            // fill with zeros
-            let zeros = vec![0; (offset - cur_offset) as usize];
-
-            debug!("writing {} zeros", zeros.len());
-
-            if let Err(err) = writer.write_all(&zeros) {
-                debug!("writing zeros returned error: {err}");
-
-                reply.error(EIO);
-                return;
-            }
-
-            bytes_written += zeros.len();
-        }
-
-        if let Err(err) = writer.write_all(&data) {
-            debug!("writing data returned error: {err}");
-
-            reply.error(EIO);
-            return;
-        }
-
-        bytes_written += data.len();
-
-        if offset + bytes_written as u64 > inode.size() {
-            debug!("write increased file size, updating...");
-
-            let new_file_size = offset + bytes_written as u64;
-
-            inode.update_size(new_file_size);
-
-            if let Err(err) = inode.write_back(&self.fat_fs) {
-                debug!("error while writing back inode: {err}");
-
-                reply.error(EIO);
-                return;
-            }
-        }
-
-        // TODO: update write and access time
-
-        reply.written(bytes_written as u32);
+        debug!(
+            "[Not Implemented] write(ino: {:#x?}, fh: {}, offset: {}, data.len(): {}, \
+            write_flags: {:#x?}, flags: {:#x?}, lock_owner: {:?})",
+            ino,
+            fh,
+            offset,
+            data.len(),
+            write_flags,
+            flags,
+            lock_owner
+        );
+        reply.error(ENOSYS);
     }
 
     fn flush(
@@ -618,64 +258,26 @@ impl Filesystem for FatFuse {
         _req: &fuser::Request<'_>,
         ino: u64,
         fh: u64,
-        _lock_owner: u64,
+        lock_owner: u64,
         reply: fuser::ReplyEmpty,
     ) {
-        debug!("flushing ino={ino} fh={fh}");
-
-        let Some(inode) = self.get_inode_by_fh(fh) else {
-            debug!("expected fh {fh} to be mapped to ino {ino}, but not found instead");
-
-            reply.error(EBADF);
-            return;
-        };
-
-        let inode = inode.borrow();
-
-        if inode.ino() != ino {
-            debug!(
-                "expected fh {fh} to be mapped to ino {ino}, but was mapped to {} instead",
-                inode.ino()
-            );
-
-            reply.error(EBADF);
-            return;
-        }
-
-        if inode.is_dir() {
-            debug!("called flush on directory (ino: {ino}, fh: {fh}");
-
-            reply.error(EISDIR);
-            return;
-        }
-
-        reply.ok();
+        debug!(
+            "[Not Implemented] flush(ino: {:#x?}, fh: {}, lock_owner: {:?})",
+            ino, fh, lock_owner
+        );
+        reply.error(ENOSYS);
     }
 
     fn release(
         &mut self,
         _req: &fuser::Request<'_>,
-        ino: u64,
-        fh: u64,
+        _ino: u64,
+        _fh: u64,
         _flags: i32,
         _lock_owner: Option<u64>,
         _flush: bool,
         reply: fuser::ReplyEmpty,
     ) {
-        let Some(found_ino) = self.ino_by_fh.remove(&fh) else {
-            debug!("tried to release fh {fh} with ino {ino}, but no ino was found in mapping");
-
-            reply.error(EBADF);
-            return;
-        };
-
-        if found_ino != ino {
-            debug!("tried to release fh {fh} with ino {ino}, but found ino is {found_ino} instead");
-
-            reply.error(EINVAL);
-            return;
-        }
-
         reply.ok();
     }
 
@@ -684,54 +286,21 @@ impl Filesystem for FatFuse {
         _req: &fuser::Request<'_>,
         ino: u64,
         fh: u64,
-        _datasync: bool,
+        datasync: bool,
         reply: fuser::ReplyEmpty,
     ) {
-        debug!("flushing ino={ino} fh={fh}");
-
-        let Some(inode) = self.get_inode_by_fh(fh) else {
-            debug!("expected fh {fh} to be mapped to ino {ino}, but not found instead");
-
-            reply.error(EBADF);
-            return;
-        };
-
-        let inode = inode.borrow();
-
-        if inode.ino() != ino {
-            debug!(
-                "expected fh {fh} to be mapped to ino {ino}, but was mapped to {} instead",
-                inode.ino()
-            );
-
-            reply.error(EBADF);
-            return;
-        }
-
-        if !inode.is_dir() {
-            debug!("called fsync on directory (ino: {ino}, fh: {fh}");
-
-            reply.error(EISDIR);
-            return;
-        }
-
-        reply.ok();
+        debug!("[Not Implemented] fsync(ino: {:#x?}, fh: {}, datasync: {})", ino, fh, datasync);
+        reply.error(ENOSYS);
     }
 
     fn opendir(
         &mut self,
         _req: &fuser::Request<'_>,
-        ino: u64,
+        _ino: u64,
         _flags: i32,
         reply: fuser::ReplyOpen,
     ) {
-        let fh = self.next_fh();
-
-        if let Some(old_ino) = self.ino_by_fh.insert(fh, ino) {
-            debug!("fh {} was already associated with ino {}, now with ino {}", fh, old_ino, ino);
-        }
-
-        reply.opened(fh, 0);
+        reply.opened(0, 0);
     }
 
     fn readdir(
@@ -740,85 +309,10 @@ impl Filesystem for FatFuse {
         ino: u64,
         fh: u64,
         offset: i64,
-        mut reply: fuser::ReplyDirectory,
+        reply: fuser::ReplyDirectory,
     ) {
-        let Ok(mut offset): Result<usize, _> = offset.try_into() else {
-            return;
-        };
-
-        let Some(dir_inode) = self.get_inode_by_fh(fh).cloned() else {
-            debug!("could not find inode accociated with fh {} (ino: {})", fh, ino);
-
-            reply.error(EBADF);
-            return;
-        };
-
-        let dir_inode = dir_inode.borrow();
-
-        if dir_inode.ino() != ino {
-            debug!(
-                "ino {} of inode associated with fh {} does not match given ino {}",
-                dir_inode.ino(),
-                fh,
-                ino
-            );
-
-            reply.error(EINVAL);
-            return;
-        }
-
-        let mut _next_idx = 1;
-        let mut next_offset = || {
-            let next_idx = _next_idx;
-            _next_idx += 1;
-            next_idx
-        };
-
-        if dir_inode.is_root() {
-            if offset == 0 {
-                debug!("adding . to root dir");
-                if reply.add(1, next_offset(), FileType::Directory, ".") {
-                    return;
-                }
-            } else {
-                offset -= 1;
-            }
-
-            if offset == 0 {
-                debug!("adding .. to root dir");
-                if reply.add(1, next_offset(), FileType::Directory, "..") {
-                    return;
-                }
-            } else {
-                offset -= 1;
-            }
-        }
-
-        let Ok(dir_iter) = dir_inode.dir_iter(&self.fat_fs) else {
-            reply.error(ENOTDIR);
-            return;
-        };
-
-        // need to drop dir_iter here so we can borrow self mut again
-        // also skip over `offset` entries
-        let dirs: Vec<DirEntry> = dir_iter.skip(offset).collect();
-
-        for dir_entry in dirs {
-            let name = dir_entry.name_string();
-
-            let inode = self.get_or_make_inode(&dir_entry, &dir_inode);
-
-            let inode = inode.borrow();
-
-            debug!("adding entry {} (ino: {})", name, inode.ino());
-            if reply.add(ino, next_offset(), inode.kind().into(), name) {
-                return;
-            }
-        }
-
-        reply.ok();
-
-        // TODO: update access time
+        warn!("[Not Implemented] readdir(ino: {:#x?}, fh: {}, offset: {})", ino, fh, offset);
+        reply.error(ENOSYS);
     }
 
     fn readdirplus(
@@ -839,36 +333,11 @@ impl Filesystem for FatFuse {
     fn releasedir(
         &mut self,
         _req: &fuser::Request<'_>,
-        ino: u64,
-        fh: u64,
+        _ino: u64,
+        _fh: u64,
         _flags: i32,
         reply: fuser::ReplyEmpty,
     ) {
-        let Some(ino) = self.ino_by_fh.remove(&fh) else {
-            debug!("can't find inode {} by fh {}", ino, fh);
-
-            reply.error(EBADF);
-            return;
-        };
-
-        let Some(inode) = self.get_inode(ino) else {
-            debug!("ino {} not associated with an inode", ino);
-
-            reply.ok();
-            return;
-        };
-
-        let inode = inode.borrow();
-
-        if inode.ino() != ino {
-            debug!(
-                "inode with ino {}, associated with fh {}, does not have expected ino {}",
-                inode.ino(),
-                fh,
-                ino
-            );
-        }
-
         reply.ok();
     }
 
@@ -891,6 +360,62 @@ impl Filesystem for FatFuse {
         reply.statfs(0, 0, 0, 0, 0, 512, 255, 0);
     }
 
+    fn setxattr(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        name: &std::ffi::OsStr,
+        _value: &[u8],
+        flags: i32,
+        position: u32,
+        reply: fuser::ReplyEmpty,
+    ) {
+        debug!(
+            "[Not Implemented] setxattr(ino: {:#x?}, name: {:?}, flags: {:#x?}, position: {})",
+            ino, name, flags, position
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn getxattr(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        name: &std::ffi::OsStr,
+        size: u32,
+        reply: fuser::ReplyXattr,
+    ) {
+        debug!("[Not Implemented] getxattr(ino: {:#x?}, name: {:?}, size: {})", ino, name, size);
+        reply.error(ENOSYS);
+    }
+
+    fn listxattr(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        size: u32,
+        reply: fuser::ReplyXattr,
+    ) {
+        debug!("[Not Implemented] listxattr(ino: {:#x?}, size: {})", ino, size);
+        reply.error(ENOSYS);
+    }
+
+    fn removexattr(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        name: &std::ffi::OsStr,
+        reply: fuser::ReplyEmpty,
+    ) {
+        debug!("[Not Implemented] removexattr(ino: {:#x?}, name: {:?})", ino, name);
+        reply.error(ENOSYS);
+    }
+
+    fn access(&mut self, _req: &fuser::Request<'_>, ino: u64, mask: i32, reply: fuser::ReplyEmpty) {
+        debug!("[Not Implemented] access(ino: {:#x?}, mask: {})", ino, mask);
+        reply.error(ENOSYS);
+    }
+
     fn create(
         &mut self,
         _req: &fuser::Request<'_>,
@@ -908,4 +433,140 @@ impl Filesystem for FatFuse {
         );
         reply.error(ENOSYS);
     }
+
+    fn getlk(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        fh: u64,
+        lock_owner: u64,
+        start: u64,
+        end: u64,
+        typ: i32,
+        pid: u32,
+        reply: fuser::ReplyLock,
+    ) {
+        debug!(
+            "[Not Implemented] getlk(ino: {:#x?}, fh: {}, lock_owner: {}, start: {}, \
+            end: {}, typ: {}, pid: {})",
+            ino, fh, lock_owner, start, end, typ, pid
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn setlk(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        fh: u64,
+        lock_owner: u64,
+        start: u64,
+        end: u64,
+        typ: i32,
+        pid: u32,
+        sleep: bool,
+        reply: fuser::ReplyEmpty,
+    ) {
+        debug!(
+            "[Not Implemented] setlk(ino: {:#x?}, fh: {}, lock_owner: {}, start: {}, \
+            end: {}, typ: {}, pid: {}, sleep: {})",
+            ino, fh, lock_owner, start, end, typ, pid, sleep
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn bmap(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        blocksize: u32,
+        idx: u64,
+        reply: fuser::ReplyBmap,
+    ) {
+        debug!(
+            "[Not Implemented] bmap(ino: {:#x?}, blocksize: {}, idx: {})",
+            ino, blocksize, idx,
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn ioctl(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        fh: u64,
+        flags: u32,
+        cmd: u32,
+        in_data: &[u8],
+        out_size: u32,
+        reply: fuser::ReplyIoctl,
+    ) {
+        debug!(
+            "[Not Implemented] ioctl(ino: {:#x?}, fh: {}, flags: {}, cmd: {}, \
+            in_data.len(): {}, out_size: {})",
+            ino,
+            fh,
+            flags,
+            cmd,
+            in_data.len(),
+            out_size,
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn fallocate(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        fh: u64,
+        offset: i64,
+        length: i64,
+        mode: i32,
+        reply: fuser::ReplyEmpty,
+    ) {
+        debug!(
+            "[Not Implemented] fallocate(ino: {:#x?}, fh: {}, offset: {}, \
+            length: {}, mode: {})",
+            ino, fh, offset, length, mode
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn lseek(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino: u64,
+        fh: u64,
+        offset: i64,
+        whence: i32,
+        reply: fuser::ReplyLseek,
+    ) {
+        debug!(
+            "[Not Implemented] lseek(ino: {:#x?}, fh: {}, offset: {}, whence: {})",
+            ino, fh, offset, whence
+        );
+        reply.error(ENOSYS);
+    }
+
+    fn copy_file_range(
+        &mut self,
+        _req: &fuser::Request<'_>,
+        ino_in: u64,
+        fh_in: u64,
+        offset_in: i64,
+        ino_out: u64,
+        fh_out: u64,
+        offset_out: i64,
+        len: u64,
+        flags: u32,
+        reply: fuser::ReplyWrite,
+    ) {
+        debug!(
+            "[Not Implemented] copy_file_range(ino_in: {:#x?}, fh_in: {}, \
+            offset_in: {}, ino_out: {:#x?}, fh_out: {}, offset_out: {}, \
+            len: {}, flags: {})",
+            ino_in, fh_in, offset_in, ino_out, fh_out, offset_out, len, flags
+        );
+        reply.error(ENOSYS);
+    }
 }
diff --git a/fat-fuse/src/inode.rs b/fat-fuse/src/inode.rs
index bff9ef1..d46d143 100644
--- a/fat-fuse/src/inode.rs
+++ b/fat-fuse/src/inode.rs
@@ -1,14 +1,10 @@
 use std::cell::{LazyCell, RefCell};
-use std::rc::Rc;
 use std::time::SystemTime;
 
 use chrono::{NaiveDateTime, NaiveTime};
 use fat_bits::FatFs;
 use fat_bits::dir::{DirEntry, DirIter};
-use fat_bits::iter::{ClusterChainReader, ClusterChainWriter};
 use fuser::FileAttr;
-use libc::{EISDIR, ENOENT, ENOTDIR};
-use log::debug;
 use rand::{Rng, SeedableRng as _};
 
 thread_local! {
@@ -23,10 +19,13 @@ thread_local! {
 static RNG: LazyCell<RefCell<rand::rngs::SmallRng>> = LazyCell::new(|| RefCell::new(rand::rngs::SmallRng::from_os_rng()));
 }
 
-fn get_random<T>() -> T
-where
-    rand::distr::StandardUniform: rand::distr::Distribution<T>,
-{
+fn get_random_u32() -> u32 {
+    // RNG.with(|x| unsafe {
+    //     let rng = &mut (*x.get());
+
+    //     rng.random::<u32>()
+    // })
+
     RNG.with(|rng| rng.borrow_mut().random())
 }
 
@@ -45,81 +44,38 @@ impl From<Kind> for fuser::FileType {
     }
 }
 
-pub const ROOT_INO: u64 = 1;
-
-pub type InodeRef = Rc<RefCell<Inode>>;
-// pub type InodeWeak = Weak<RefCell<Inode>>;
+const ROOT_INO: u64 = 1;
 
 #[derive(Debug)]
 #[allow(dead_code)]
 pub struct Inode {
     ino: u64,
-    // FUSE uses a u64 for generation, but the Linux kernel only handles u32s anyway, truncating
-    // the high bits, so using more is pretty pointless and possibly even detrimental
     generation: u32,
 
-    ref_count: u64,
-
-    uid: u32,
-    gid: u32,
-
-    path: Rc<str>,
-
-    parent: Option<InodeRef>,
-
+    size: u64,
     block_size: u32,
 
     kind: Kind,
 
     read_only: bool,
 
-    dirty: bool,
-
-    // these are the fields that have to get written back to the DirEntry on write_back
-    size: u64,
-
     atime: SystemTime,
     mtime: SystemTime,
+    // ctime: SystemTime,
     crtime: SystemTime,
 
+    uid: u32,
+    gid: u32,
+
     first_cluster: u32,
 }
 
-impl Drop for Inode {
-    fn drop(&mut self) {
-        // since we don't have a handle on the FatFs we can't do the write-back here
-        assert!(
-            !self.dirty,
-            "inode {} is dirty, but was not written back to FS before being destroyed",
-            self.ino()
-        );
-    }
-}
-
+#[allow(dead_code)]
 impl Inode {
-    fn new_generation() -> u32 {
-        let rand: u16 = get_random();
-
-        let secs = SystemTime::UNIX_EPOCH
-            .elapsed()
-            .map(|dur| dur.as_secs() as u16)
-            .unwrap_or(0);
-
-        ((secs as u32) << 16) | rand as u32
-    }
-
-    pub fn new(
-        fat_fs: &FatFs,
-        dir_entry: &DirEntry,
-        ino: u64,
-        uid: u32,
-        gid: u32,
-        path: impl Into<Rc<str>>,
-        parent: InodeRef,
-    ) -> Inode {
+    pub fn new(fat_fs: &FatFs, dir_entry: DirEntry, uid: u32, gid: u32) -> Inode {
         assert!(dir_entry.is_file() || dir_entry.is_dir());
 
-        let generation = Self::new_generation();
+        let generation = get_random_u32();
 
         let kind = if dir_entry.is_dir() {
             Kind::Dir
@@ -139,138 +95,22 @@ impl Inode {
         let mtime = datetime_to_system(dir_entry.write_time());
         let crtime = datetime_to_system(dir_entry.create_time());
 
-        let path = path.into();
-
-        debug!(
-            "creating new inode: ino: {}    name: {}    path: {}",
-            ino,
-            dir_entry.name_string(),
-            path
-        );
-
         Inode {
-            ino,
+            ino: dir_entry.first_cluster() as u64,
             generation,
-            ref_count: 0,
-            parent: Some(parent),
             size: dir_entry.file_size() as u64,
-            block_size: fat_fs.bytes_per_sector() as u32,
+            block_size: fat_fs.bpb().bytes_per_sector() as u32,
             kind,
             read_only: dir_entry.is_readonly(),
-            dirty: false,
             atime,
             mtime,
             crtime,
             uid,
             gid,
             first_cluster: dir_entry.first_cluster(),
-            path,
         }
     }
 
-    pub fn root_inode(fat_fs: &FatFs, uid: u32, gid: u32) -> Inode {
-        let root_cluster = fat_fs.root_cluster().unwrap_or(0);
-
-        Inode {
-            ino: ROOT_INO,
-            generation: 0, // root cluster always has constant generation of 0
-            ref_count: 0,
-            parent: None, // parent is self
-            size: 0,
-            block_size: fat_fs.bytes_per_sector() as u32,
-            kind: Kind::Dir,
-            read_only: false,
-            dirty: false,
-            atime: SystemTime::UNIX_EPOCH,
-            mtime: SystemTime::UNIX_EPOCH,
-            crtime: SystemTime::UNIX_EPOCH,
-            uid,
-            gid,
-            first_cluster: root_cluster,
-            path: "/".into(),
-        }
-    }
-
-    pub fn ino(&self) -> u64 {
-        self.ino
-    }
-
-    pub fn generation(&self) -> u32 {
-        self.generation
-    }
-
-    pub fn ref_count(&self) -> u64 {
-        self.ref_count
-    }
-
-    pub fn inc_ref_count(&mut self) {
-        debug!(
-            "increasing ref_count of ino {} by 1 (new ref_count: {})",
-            self.ino(),
-            self.ref_count() + 1
-        );
-
-        self.ref_count += 1;
-    }
-
-    pub fn dec_ref_count(&mut self, n: u64) -> u64 {
-        debug!(
-            "decreasing ref_count of ino {} by {} (new ref_count: {})",
-            self.ino(),
-            n,
-            self.ref_count().saturating_sub(n),
-        );
-
-        if self.ref_count < n {
-            debug!(
-                "inode {}: tried to decrement refcount by {}, but is only {}",
-                self.ino(),
-                n,
-                self.ref_count
-            );
-        }
-
-        self.ref_count = self.ref_count.saturating_sub(n);
-
-        self.ref_count
-    }
-
-    pub fn parent(&self) -> Option<&InodeRef> {
-        self.parent.as_ref()
-    }
-
-    pub fn size(&self) -> u64 {
-        self.size
-    }
-
-    pub fn kind(&self) -> Kind {
-        self.kind
-    }
-
-    pub fn is_file(&self) -> bool {
-        self.kind == Kind::File
-    }
-
-    pub fn is_dir(&self) -> bool {
-        self.kind == Kind::Dir
-    }
-
-    pub fn is_read_only(&self) -> bool {
-        self.read_only
-    }
-
-    pub fn first_cluster(&self) -> u32 {
-        self.first_cluster
-    }
-
-    pub fn path(&self) -> Rc<str> {
-        Rc::clone(&self.path)
-    }
-
-    pub fn is_root(&self) -> bool {
-        self.ino == ROOT_INO
-    }
-
     pub fn file_attr(&self) -> FileAttr {
         let perm = if self.read_only { 0o555 } else { 0o777 };
 
@@ -293,123 +133,21 @@ impl Inode {
         }
     }
 
-    pub fn dir_iter<'a>(&'a self, fat_fs: &'a FatFs) -> Result<DirIter<'a>, i32> {
-        if self.kind != Kind::Dir {
-            return Err(ENOTDIR);
-        }
+    pub fn dir_iter(&self, fat_fs: &FatFs) -> anyhow::Result<impl Iterator<Item = DirEntry>> {
+        anyhow::ensure!(self.kind == Kind::Dir, "cannot dir_iter on a file");
 
-        if self.is_root() {
+        // TODO: the boxing here is not particularly pretty, but neccessary, since the DirIter for
+        // the root holds a
+
+        if self.ino == ROOT_INO {
             // root dir
 
             return Ok(fat_fs.root_dir_iter());
         }
 
-        Ok(fat_fs.dir_iter(self.first_cluster))
-    }
+        let chain_reader = fat_fs.chain_reader(self.first_cluster);
 
-    pub fn find_child_by_name(&self, fat_fs: &FatFs, name: &str) -> Result<DirEntry, i32> {
-        self.dir_iter(fat_fs)
-            .and_then(|mut dir_iter| dir_iter.find_by_name(name).ok_or(ENOENT))
-    }
-
-    pub fn file_reader<'a>(&'a self, fat_fs: &'a FatFs) -> Result<ClusterChainReader<'a>, i32> {
-        if self.is_dir() {
-            return Err(EISDIR);
-        }
-
-        Ok(fat_fs.file_reader(self.first_cluster()))
-    }
-
-    pub fn file_writer<'a>(&'a self, fat_fs: &'a mut FatFs) -> Result<ClusterChainWriter<'a>, i32> {
-        if self.is_dir() {
-            return Err(EISDIR);
-        }
-
-        Ok(fat_fs.file_writer(self.first_cluster()))
-    }
-
-    pub fn update_size(&mut self, new_size: u64) {
-        debug!("updating size to {new_size}");
-
-        if new_size == self.size {
-            return;
-        }
-
-        self.size = new_size;
-        self.dirty = true;
-    }
-
-    pub fn update_atime(&mut self, atime: SystemTime) {
-        if self.atime == atime {
-            return;
-        }
-
-        self.atime = atime;
-        self.dirty = true;
-    }
-
-    pub fn update_mtime(&mut self, mtime: SystemTime) {
-        if self.mtime == mtime {
-            return;
-        }
-
-        self.mtime = mtime;
-        self.dirty = true;
-    }
-
-    pub fn write_back(&mut self, fat_fs: &FatFs) -> anyhow::Result<()> {
-        if !self.dirty {
-            return Ok(());
-        }
-
-        if self.is_root() {
-            // root dir has no attributes
-
-            self.dirty = false;
-            return Ok(());
-        }
-
-        let Some(parent_inode) = self.parent() else {
-            anyhow::bail!("parent inode of {} does not exist", self.ino);
-        };
-
-        let parent_inode = parent_inode.borrow();
-
-        // since we just wrote to the file with this inode, first cluster should not be zero
-        let Some(mut dir_entry) = parent_inode
-            .dir_iter(fat_fs)
-            .unwrap()
-            .find(|dir_entry| dir_entry.first_cluster() == self.first_cluster())
-        else {
-            anyhow::bail!("could not find dir_entry corresponding to self in parent inode");
-        };
-
-        drop(parent_inode);
-
-        // update stats on DirEntry
-        assert!(self.size <= u32::MAX as u64);
-
-        dir_entry.update_file_size(self.size as u32);
-
-        dir_entry
-            .update_last_access_date(self.atime)
-            .map_err(|err| {
-                anyhow::anyhow!("failed to update atime for inode {}: {err}", self.ino)
-            })?;
-
-        dir_entry.update_write_time(self.mtime).map_err(|err| {
-            anyhow::anyhow!("failed to update mtime for inode {}: {err}", self.ino)
-        })?;
-
-        // update cr_time as well?
-
-        // write DirEntry back to device
-        dir_entry.write_back(fat_fs).map_err(|err| {
-            anyhow::anyhow!("failed to write back dir_entry for inode {}: {err}", self.ino)
-        })?;
-
-        self.dirty = false;
-
-        Ok(())
+        // TODO: get rid of this Box if the boxing is removed from root_dir_iter
+        Ok(DirIter::new(Box::new(chain_reader)))
     }
 }
diff --git a/fat-fuse/src/lib.rs b/fat-fuse/src/lib.rs
index 9c4ca3f..b8499d8 100644
--- a/fat-fuse/src/lib.rs
+++ b/fat-fuse/src/lib.rs
@@ -5,12 +5,9 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::rc::Rc;
 
-use fat_bits::dir::DirEntry;
 use fat_bits::{FatFs, SliceLike};
-use fxhash::FxHashMap;
-use log::{debug, error};
 
-use crate::inode::{Inode, InodeRef};
+use crate::inode::Inode;
 
 #[allow(dead_code)]
 pub struct FatFuse {
@@ -19,279 +16,32 @@ pub struct FatFuse {
     uid: u32,
     gid: u32,
 
-    next_ino: u64,
-    next_fh: u64,
+    next_fd: u32,
 
-    inode_table: BTreeMap<u64, InodeRef>,
-
-    ino_by_first_cluster: BTreeMap<u32, u64>,
-    ino_by_fh: BTreeMap<u64, u64>,
-    ino_by_path: FxHashMap<Rc<str>, u64>,
+    inode_table: BTreeMap<u64, Inode>,
 }
 
-/// SAFETY
-///
-/// do NOT leak Rc<str> from this type
-unsafe impl Send for FatFuse {}
-
 impl FatFuse {
-    pub fn new<S>(data: S) -> anyhow::Result<FatFuse>
-    where
-        S: SliceLike + Send + 'static,
-    {
+    pub fn new(data: Rc<RefCell<dyn SliceLike>>) -> anyhow::Result<FatFuse> {
         let uid = unsafe { libc::getuid() };
         let gid = unsafe { libc::getgid() };
 
         let fat_fs = FatFs::load(data)?;
 
-        let mut fat_fuse = FatFuse {
+        Ok(FatFuse {
             fat_fs,
             uid,
             gid,
-            next_ino: 2, // 0 is reserved and 1 is root
-            next_fh: 0,
+            next_fd: 0,
             inode_table: BTreeMap::new(),
-            ino_by_first_cluster: BTreeMap::new(),
-            ino_by_fh: BTreeMap::new(),
-            ino_by_path: FxHashMap::default(),
-        };
-
-        // TODO: build and insert root dir inode
-
-        let root_inode = Inode::root_inode(&fat_fuse.fat_fs, uid, gid);
-
-        fat_fuse.insert_inode(root_inode);
-
-        Ok(fat_fuse)
+        })
     }
 
-    fn next_ino(&mut self) -> u64 {
-        let ino = self.next_ino;
-
-        assert!(!self.inode_table.contains_key(&ino));
-
-        self.next_ino += 1;
-
-        ino
-    }
-
-    fn next_fh(&mut self) -> u64 {
-        let fh = self.next_fh;
-
-        assert!(!self.ino_by_fh.contains_key(&fh));
-
-        self.next_fh += 1;
-
-        fh
-    }
-
-    fn insert_inode(&mut self, inode: Inode) -> InodeRef {
-        let ino = inode.ino();
-        let generation = inode.generation();
-        let first_cluster = inode.first_cluster();
-
-        // let old_inode = self.inode_table.insert(ino, inode);
-
-        let inode = Rc::new(RefCell::new(inode));
-
-        let entry = self.inode_table.entry(ino);
-
-        let (new_inode, old_inode) = match entry {
-            std::collections::btree_map::Entry::Vacant(vacant_entry) => {
-                let new_inode = vacant_entry.insert(inode);
-                (Rc::clone(new_inode), None)
-            }
-            std::collections::btree_map::Entry::Occupied(occupied_entry) => {
-                let entry_ref = occupied_entry.into_mut();
-
-                let old_inode = std::mem::replace(entry_ref, inode);
-
-                (Rc::clone(entry_ref), Some(old_inode))
-            }
-        };
-
-        debug!(
-            "inserted new inode with ino {} and generation {} (first cluster: {})",
-            ino, generation, first_cluster
-        );
-
-        if let Some(old_inode) = old_inode {
-            let old_inode = old_inode.borrow();
-
-            debug!("ejected inode {} {}", old_inode.ino(), old_inode.generation());
-        }
-
-        if first_cluster != 0 {
-            if let Some(old_ino) = self.ino_by_first_cluster.insert(first_cluster, ino) {
-                debug!("ejected old {} -> {} cluster to ino mapping", first_cluster, old_ino);
-            }
-        }
-
-        let path = new_inode.borrow().path();
-
-        if let Some(old_ino) = self.ino_by_path.insert(Rc::clone(&path), ino) {
-            debug!("ejected old {} -> {} path to ino mapping", path, old_ino);
-        }
-
-        new_inode
-    }
-
-    fn drop_inode(&mut self, inode: InodeRef) {
-        let inode = inode.borrow();
-
-        let ino = inode.ino();
-
-        debug!("dropping inode {}", ino);
-
-        if self.inode_table.remove(&ino).is_none() {
-            error!("tried to drop inode with ino {}, but was not in table", ino);
-
-            return;
-        };
-
-        let first_cluster = inode.first_cluster();
-
-        if first_cluster != 0 {
-            let entry = self.ino_by_first_cluster.entry(first_cluster);
-
-            match entry {
-                std::collections::btree_map::Entry::Vacant(_) => debug!(
-                    "removed inode with ino {} from table, but it's first cluster did not point to any ino",
-                    ino
-                ),
-                std::collections::btree_map::Entry::Occupied(occupied_entry) => {
-                    let found_ino = *occupied_entry.get();
-
-                    if found_ino == ino {
-                        // matches our inode, remove it
-                        occupied_entry.remove();
-                    } else {
-                        // does not match removed inode, leave it as is
-                        debug!(
-                            "removed inode with ino {} from table, but its first cluster pointed to ino {} instead",
-                            ino, found_ino
-                        );
-                    }
-                }
-            }
-        }
-
-        {
-            let entry = self.ino_by_path.entry(inode.path());
-
-            match entry {
-                std::collections::hash_map::Entry::Vacant(_) => debug!(
-                    "removed inode with ino {} from table, but it's path did not point to any ino",
-                    ino
-                ),
-                std::collections::hash_map::Entry::Occupied(occupied_entry) => {
-                    let found_ino = *occupied_entry.get();
-
-                    if found_ino == ino {
-                        // matches our inode, remove it
-                        occupied_entry.remove();
-                    } else {
-                        // does not match removed inode, leave it as is
-                        debug!(
-                            "removed inode with ino {} from table, but its path pointed to ino {} instead",
-                            ino, found_ino
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    fn get_inode(&self, ino: u64) -> Option<&InodeRef> {
+    fn get_inode(&self, ino: u64) -> Option<&Inode> {
         self.inode_table.get(&ino)
     }
 
-    fn get_or_make_inode(&mut self, dir_entry: &DirEntry, parent: &Inode) -> InodeRef {
-        // let parent = parent.borrow();
-
-        // try to find inode by first cluster first
-        if dir_entry.first_cluster() != 0
-            && let Some(inode) = self.get_inode_by_first_cluster(dir_entry.first_cluster())
-        {
-            return inode;
-        }
-
-        // try to find inode by path
-        // mostly for empty files/directories which have a first cluster of 0
-
-        let path = {
-            let mut path = parent.path().as_ref().to_owned();
-
-            if parent.ino() != inode::ROOT_INO {
-                // root inode already has trailing slash
-                path.push('/');
-            }
-
-            path += &dir_entry.name_string();
-
-            path
-        };
-
-        if let Some(inode) = self.get_inode_by_path(&path) {
-            return inode;
-        }
-
-        // no inode found, make a new one
-        let ino = self.next_ino();
-
-        let Some(parent_inode) = self.get_inode(parent.ino()).cloned() else {
-            // TODO: what do we do here? should not happen
-            panic!("parent_ino {} does not lead to inode", parent.ino());
-        };
-
-        let inode =
-            Inode::new(&self.fat_fs, dir_entry, ino, self.uid, self.gid, path, parent_inode);
-
-        self.insert_inode(inode)
-    }
-
-    pub fn get_inode_by_first_cluster(&self, first_cluster: u32) -> Option<InodeRef> {
-        if first_cluster == 0 {
-            debug!("trying to get inode by first cluster 0");
-
-            return None;
-        }
-
-        let ino = self.ino_by_first_cluster.get(&first_cluster)?;
-
-        if let Some(inode) = self.inode_table.get(ino) {
-            Some(Rc::clone(inode))
-        } else {
-            debug!(
-                "first cluster {} is mapped to ino {}, but inode is not in table",
-                first_cluster, ino
-            );
-
-            None
-        }
-    }
-
-    pub fn get_inode_by_fh(&self, fh: u64) -> Option<&InodeRef> {
-        let ino = *self.ino_by_fh.get(&fh)?;
-
-        if let Some(inode) = self.get_inode(ino) {
-            Some(inode)
-        } else {
-            debug!("fh {} is mapped to ino {}, but inode is not in table", fh, ino);
-
-            None
-        }
-    }
-
-    pub fn get_inode_by_path(&self, path: &str) -> Option<InodeRef> {
-        let ino = *self.ino_by_path.get(path)?;
-
-        if let Some(inode) = self.get_inode(ino).cloned() {
-            Some(inode)
-        } else {
-            debug!("path {} is mapped to ino {}, but inode is not in table", path, ino);
-
-            None
-        }
+    fn get_inode_mut(&mut self, ino: u64) -> Option<&mut Inode> {
+        self.inode_table.get_mut(&ino)
     }
 }
diff --git a/fat-mount/Cargo.toml b/fat-mount/Cargo.toml
deleted file mode 100644
index ba48f80..0000000
--- a/fat-mount/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "fat-mount"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-anyhow = "1.0.98"
-ctrlc = "3.4.7"
-env_logger = "0.11.8"
-fat-fuse = { version = "0.1.0", path = "../fat-fuse" }
-fuser = "0.15.1"
diff --git a/fat-mount/src/main.rs b/fat-mount/src/main.rs
deleted file mode 100644
index 5a85ce6..0000000
--- a/fat-mount/src/main.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use std::fs::OpenOptions;
-use std::sync::mpsc::channel;
-
-use fat_fuse::FatFuse;
-use fuser::MountOption;
-
-fn main() -> anyhow::Result<()> {
-    env_logger::init();
-
-    let mut args = std::env::args();
-
-    let _prog_name = args.next().unwrap();
-    let path = args.next().ok_or(anyhow::anyhow!("missing fs path"))?;
-    let mountpoint = args.next().ok_or(anyhow::anyhow!("missing mount point"))?;
-
-    // let file = File::open(path)?;
-    let file = OpenOptions::new().read(true).write(true).open(path)?;
-
-    let fat_fuse = FatFuse::new(file)?;
-
-    let options = vec![
-        // MountOption::RO,
-        MountOption::FSName("fat-fuse".to_owned()),
-        MountOption::AutoUnmount,
-    ];
-
-    let (tx, rx) = channel();
-
-    ctrlc::set_handler(move || {
-        tx.send(()).unwrap();
-    })
-    .unwrap();
-
-    let handle = fuser::spawn_mount2(fat_fuse, mountpoint, &options)?;
-
-    rx.recv().unwrap();
-
-    handle.join();
-
-    Ok(())
-}