diff --git a/litebox_runner_linux_on_windows_userland/tests/common/mod.rs b/litebox_runner_linux_on_windows_userland/tests/common/mod.rs
index a762f4fe1..8333d3185 100644
--- a/litebox_runner_linux_on_windows_userland/tests/common/mod.rs
+++ b/litebox_runner_linux_on_windows_userland/tests/common/mod.rs
@@ -10,7 +10,7 @@ use litebox_platform_multiplex::Platform;
 
 pub struct TestLauncher {
     platform: &'static Platform,
-    shim_builder: litebox_shim_linux::LinuxShimBuilder,
+    shim_builder: litebox_shim_linux::LinuxShimBuilder<litebox_shim_linux::DefaultFS>,
     fs: litebox_shim_linux::DefaultFS,
 }
 
diff --git a/litebox_runner_linux_userland/tests/loader.rs b/litebox_runner_linux_userland/tests/loader.rs
index e6a0599b4..26a15f77d 100644
--- a/litebox_runner_linux_userland/tests/loader.rs
+++ b/litebox_runner_linux_userland/tests/loader.rs
@@ -11,7 +11,7 @@ use litebox_platform_multiplex::Platform;
 
 struct TestLauncher {
     platform: &'static Platform,
-    shim_builder: litebox_shim_linux::LinuxShimBuilder,
+    shim_builder: litebox_shim_linux::LinuxShimBuilder<litebox_shim_linux::DefaultFS>,
     fs: litebox_shim_linux::DefaultFS,
 }
 
diff --git a/litebox_runner_snp/src/main.rs b/litebox_runner_snp/src/main.rs
index 975437756..3a665722b 100644
--- a/litebox_runner_snp/src/main.rs
+++ b/litebox_runner_snp/src/main.rs
@@ -16,7 +16,7 @@ use litebox_platform_linux_kernel::{HostInterface, host::snp::ghcb::ghcb_prints}
 
 // FUTURE: replace this with some kind of OnceLock, or just eliminate this
 // entirely (ideal).
-static mut SHIM: Option<litebox_shim_linux::LinuxShim> = None;
+static mut SHIM: Option<litebox_shim_linux::LinuxShim<litebox_shim_linux::DefaultFS>> = None;
 
 #[unsafe(no_mangle)]
 pub extern "C" fn floating_point_handler(_pt_regs: &mut litebox_common_linux::PtRegs) {
diff --git a/litebox_shim_linux/src/lib.rs b/litebox_shim_linux/src/lib.rs
index f4dccc729..ed7702148 100644
--- a/litebox_shim_linux/src/lib.rs
+++ b/litebox_shim_linux/src/lib.rs
@@ -21,7 +21,7 @@ use alloc::sync::Arc;
 use core::cell::{Cell, RefCell};
 use litebox::{
     LiteBox,
-    fd::{ErrRawIntFd, TypedFd},
+    fd::TypedFd,
     mm::{PageManager, linux::PAGE_SIZE},
     net::Network,
     pipes::Pipes,
@@ -59,7 +59,11 @@ pub(crate) type LinuxFS = litebox::fs::layered::FileSystem<
     >,
 >;
 
-pub(crate) type FileFd = litebox::fd::TypedFd<LinuxFS>;
+pub(crate) type FileFd<FS> = litebox::fd::TypedFd<FS>;
+
+/// A trait required for file systems to be used in the shim.
+pub trait ShimFS: litebox::fs::FileSystem + Send + Sync + 'static {}
+impl<T: litebox::fs::FileSystem + Send + Sync + 'static> ShimFS for T {}
 
 /// On debug builds, logs that the user attempted to use an unsupported feature.
 fn log_unsupported_fmt(args: core::fmt::Arguments<'_>) {
@@ -71,14 +75,14 @@ fn log_unsupported_fmt(args: core::fmt::Arguments<'_>) {
     }
 }
 
-pub struct LinuxShimEntrypoints {
-    task: Task,
+pub struct LinuxShimEntrypoints<FS: ShimFS> {
+    task: Task<FS>,
     // The task should not be moved once it's bound to a platform thread so that
     // we preserve the ability to use TLS in the future.
     _not_send: core::marker::PhantomData<*const ()>,
 }
 
-impl litebox::shim::EnterShim for LinuxShimEntrypoints {
+impl<FS: ShimFS> litebox::shim::EnterShim for LinuxShimEntrypoints<FS> {
     type ExecutionContext = litebox_common_linux::PtRegs;
 
     fn init(&self, ctx: &mut Self::ExecutionContext) -> ContinueOperation {
@@ -102,12 +106,12 @@ impl litebox::shim::EnterShim for LinuxShimEntrypoints {
     }
 }
 
-impl LinuxShimEntrypoints {
+impl<FS: ShimFS> LinuxShimEntrypoints<FS> {
     fn enter_shim(
         &self,
         is_init: bool,
         ctx: &mut litebox_common_linux::PtRegs,
-        f: impl FnOnce(&Task, &mut litebox_common_linux::PtRegs),
+        f: impl FnOnce(&Task<FS>, &mut litebox_common_linux::PtRegs),
     ) -> ContinueOperation {
         if !is_init {
             self.task.enter_from_guest();
@@ -122,20 +126,20 @@ impl LinuxShimEntrypoints {
 }
 
 /// The shim entry point structure.
-pub struct LinuxShimBuilder {
+pub struct LinuxShimBuilder<FS: ShimFS> {
     platform: &'static Platform,
     litebox: LiteBox<Platform>,
-    fs: Option<LinuxFS>,
+    fs: Option<FS>,
     load_filter: Option<LoadFilter>,
 }
 
-impl Default for LinuxShimBuilder {
+impl<FS: ShimFS> Default for LinuxShimBuilder<FS> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl LinuxShimBuilder {
+impl<FS: ShimFS> LinuxShimBuilder<FS> {
     /// Returns a new shim builder.
     pub fn new() -> Self {
         let platform = litebox_platform_multiplex::platform();
@@ -156,7 +160,7 @@ impl LinuxShimBuilder {
     ///
     /// NOTE: This function signature might change as better parametricity is added to file systems.
     /// Related: <https://github.com/MSRSSP/litebox/issues/24>
-    pub fn set_fs(&mut self, fs: LinuxFS) {
+    pub fn set_fs(&mut self, fs: FS) {
         self.fs = Some(fs);
     }
 
@@ -179,7 +183,7 @@ impl LinuxShimBuilder {
     /// # Panics
     /// Panics if the file system has not been set with [`set_fs`](Self::set_fs)
     /// before calling this method.
-    pub fn build(self) -> LinuxShim {
+    pub fn build(self) -> LinuxShim<FS> {
         let mut net = Network::new(&self.litebox);
         net.set_platform_interaction(litebox::net::PlatformInteraction::Manual);
         let global = Arc::new(GlobalState {
@@ -201,10 +205,14 @@ impl LinuxShimBuilder {
     }
 }
 
-#[derive(Clone)]
-pub struct LinuxShim(Arc<GlobalState>);
+pub struct LinuxShim<FS: ShimFS>(Arc<GlobalState<FS>>);
+impl<FS: ShimFS> Clone for LinuxShim<FS> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
 
-impl LinuxShim {
+impl<FS: ShimFS> LinuxShim<FS> {
     /// Loads the program at `path` as the shim's initial task, returning the
     /// initial register state.
     pub fn load_program(
@@ -213,7 +221,7 @@ impl LinuxShim {
         path: &str,
         argv: Vec<alloc::ffi::CString>,
         envp: Vec<alloc::ffi::CString>,
-    ) -> Result<LoadedProgram, loader::elf::ElfLoaderError> {
+    ) -> Result<LoadedProgram<FS>, loader::elf::ElfLoaderError> {
         let litebox_common_linux::TaskParams {
             pid,
             ppid,
@@ -275,8 +283,8 @@ impl LinuxShim {
     }
 }
 
-pub struct LoadedProgram {
-    pub entrypoints: LinuxShimEntrypoints,
+pub struct LoadedProgram<FS: ShimFS> {
+    pub entrypoints: LinuxShimEntrypoints<FS>,
     pub process: LinuxShimProcess,
 }
 
@@ -319,9 +327,9 @@ fn default_fs(
 // Special override so that `GETFL` can return stdio-specific flags
 pub(crate) struct StdioStatusFlags(litebox::fs::OFlags);
 
-impl syscalls::file::FilesState {
-    fn initialize_stdio_in_shared_descriptors_table(&self, global: &GlobalState) {
-        use litebox::fs::{FileSystem as _, Mode, OFlags};
+impl<FS: ShimFS> syscalls::file::FilesState<FS> {
+    fn initialize_stdio_in_shared_descriptors_table(&self, global: &GlobalState<FS>) {
+        use litebox::fs::{Mode, OFlags};
         let stdin = global
             .fs
             .open("/dev/stdin", OFlags::RDONLY, Mode::empty())
@@ -351,11 +359,11 @@ impl syscalls::file::FilesState {
 type ConstPtr<T> = <Platform as litebox::platform::RawPointerProvider>::RawConstPointer<T>;
 type MutPtr<T> = <Platform as litebox::platform::RawPointerProvider>::RawMutPointer<T>;
 
-struct Descriptors {
-    descriptors: Vec<Option<Descriptor>>,
+struct Descriptors<FS: ShimFS> {
+    descriptors: Vec<Option<Descriptor<FS>>>,
 }
 
-impl Descriptors {
+impl<FS: ShimFS> Descriptors<FS> {
     fn new() -> Self {
         Self {
             descriptors: vec![
@@ -370,7 +378,11 @@ impl Descriptors {
     ///
     /// Returns the assigned file descriptor number, or the descriptor back on failure
     /// if the limit is exceeded.
-    fn insert(&mut self, task: &Task, descriptor: Descriptor) -> Result<u32, Descriptor> {
+    fn insert(
+        &mut self,
+        task: &Task<FS>,
+        descriptor: Descriptor<FS>,
+    ) -> Result<u32, Descriptor<FS>> {
         self.insert_in_range(
             descriptor,
             0,
@@ -385,10 +397,10 @@ impl Descriptors {
     /// or the descriptor back if no slot is found within the limit.
     fn insert_in_range(
         &mut self,
-        descriptor: Descriptor,
+        descriptor: Descriptor<FS>,
         min_idx: usize,
         max_idx: usize,
-    ) -> Result<u32, Descriptor> {
+    ) -> Result<u32, Descriptor<FS>> {
         let idx = self
             .descriptors
             .iter()
@@ -412,10 +424,10 @@ impl Descriptors {
     /// if the index exceeds the limit.
     fn insert_at(
         &mut self,
-        task: &Task,
-        descriptor: Descriptor,
+        task: &Task<FS>,
+        descriptor: Descriptor<FS>,
         idx: usize,
-    ) -> Result<Option<Descriptor>, Descriptor> {
+    ) -> Result<Option<Descriptor<FS>>, Descriptor<FS>> {
         if idx
             >= task
                 .process()
@@ -432,11 +444,11 @@ impl Descriptors {
             .get_mut(idx)
             .and_then(|v| v.replace(descriptor)))
     }
-    fn remove(&mut self, fd: u32) -> Option<Descriptor> {
+    fn remove(&mut self, fd: u32) -> Option<Descriptor<FS>> {
         let fd = fd as usize;
         self.descriptors.get_mut(fd)?.take()
     }
-    fn get_fd(&self, fd: u32) -> Option<&Descriptor> {
+    fn get_fd(&self, fd: u32) -> Option<&Descriptor<FS>> {
         self.descriptors.get(fd as usize)?.as_ref()
     }
 
@@ -445,7 +457,7 @@ impl Descriptors {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     fn close_on_exec(&self) {
         let files = self.files.borrow();
         files
@@ -467,18 +479,18 @@ impl Task {
     }
 }
 
-enum Descriptor {
+enum Descriptor<FS: ShimFS> {
     LiteBoxRawFd(usize),
     Eventfd {
         file: alloc::sync::Arc<syscalls::eventfd::EventFile<Platform>>,
         close_on_exec: core::sync::atomic::AtomicBool,
     },
     Epoll {
-        file: alloc::sync::Arc<syscalls::epoll::EpollFile>,
+        file: alloc::sync::Arc<syscalls::epoll::EpollFile<FS>>,
         close_on_exec: core::sync::atomic::AtomicBool,
     },
     Unix {
-        file: alloc::sync::Arc<syscalls::unix::UnixSocket>,
+        file: alloc::sync::Arc<syscalls::unix::UnixSocket<FS>>,
         close_on_exec: core::sync::atomic::AtomicBool,
     },
 }
@@ -487,53 +499,36 @@ enum Descriptor {
 ///
 /// This enum only ever stores `Arc<TypedFd<..>>`s, and should not store any additional data
 /// alongside them (i.e., it is a trivial tagged union across the subsystems being used).
-enum StrongFd {
-    FileSystem(Arc<TypedFd<LinuxFS>>),
+enum StrongFd<FS: ShimFS> {
+    FileSystem(Arc<TypedFd<FS>>),
     Network(Arc<TypedFd<Network<Platform>>>),
     Pipes(Arc<TypedFd<Pipes<Platform>>>),
 }
-impl StrongFd {
-    fn from_raw(files: &syscalls::file::FilesState, fd: usize) -> Result<Self, Errno> {
-        match files
-            .raw_descriptor_store
-            .read()
-            .typed_fd_at_raw_3::<StrongFd, LinuxFS, Network<Platform>, Pipes<Platform>>(fd)
-        {
-            Ok(r) => Ok(r),
-            Err(ErrRawIntFd::InvalidSubsystem) => {
-                // We currently only have net and fs FDs at the moment, when we add more, we need to
-                // expand out `StrongFd` too.
-                unreachable!()
-            }
-            Err(ErrRawIntFd::NotFound) => Err(Errno::EBADF),
+impl<FS: ShimFS> StrongFd<FS> {
+    fn from_raw(files: &syscalls::file::FilesState<FS>, fd: usize) -> Result<Self, Errno> {
+        let rds = files.raw_descriptor_store.read();
+        if let Ok(fd) = rds.fd_from_raw_integer::<FS>(fd) {
+            return Ok(StrongFd::FileSystem(fd));
         }
-    }
-}
-impl From<Arc<TypedFd<LinuxFS>>> for StrongFd {
-    fn from(v: Arc<TypedFd<LinuxFS>>) -> Self {
-        StrongFd::FileSystem(v)
-    }
-}
-impl From<Arc<TypedFd<Network<Platform>>>> for StrongFd {
-    fn from(v: Arc<TypedFd<Network<Platform>>>) -> Self {
-        StrongFd::Network(v)
-    }
-}
-impl From<Arc<TypedFd<Pipes<Platform>>>> for StrongFd {
-    fn from(v: Arc<TypedFd<Pipes<Platform>>>) -> Self {
-        StrongFd::Pipes(v)
+        if let Ok(fd) = rds.fd_from_raw_integer::<Network<Platform>>(fd) {
+            return Ok(StrongFd::Network(fd));
+        }
+        if let Ok(fd) = rds.fd_from_raw_integer::<Pipes<Platform>>(fd) {
+            return Ok(StrongFd::Pipes(fd));
+        }
+        Err(Errno::EBADF)
     }
 }
 
-impl syscalls::file::FilesState {
+impl<FS: ShimFS> syscalls::file::FilesState<FS> {
     pub(crate) fn run_on_raw_fd<R>(
         &self,
         fd: usize,
-        fs: impl FnOnce(&TypedFd<LinuxFS>) -> R,
+        fs: impl FnOnce(&TypedFd<FS>) -> R,
         net: impl FnOnce(&TypedFd<Network<Platform>>) -> R,
         pipes: impl FnOnce(&TypedFd<Pipes<Platform>>) -> R,
     ) -> Result<R, Errno> {
-        match StrongFd::from_raw(self, fd)? {
+        match StrongFd::<FS>::from_raw(self, fd)? {
             StrongFd::FileSystem(fd) => Ok(fs(&fd)),
             StrongFd::Network(fd) => Ok(net(&fd)),
             StrongFd::Pipes(fd) => Ok(pipes(&fd)),
@@ -567,7 +562,7 @@ impl ToSyscallResult for Result<u32, Errno> {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// A wrapper function around `sys_pread64` that copies data in chunks to avoid OOMing.
     fn pread_with_user_buf(
         &self,
@@ -1139,7 +1134,7 @@ impl Task {
 }
 
 /// Global shim state, shared across all tasks.
-struct GlobalState {
+struct GlobalState<FS: ShimFS> {
     /// The platform instance used throughout the shim.
     platform: &'static Platform,
     /// The LiteBox instance used throughout the shim.
@@ -1147,7 +1142,7 @@ struct GlobalState {
     /// The page manager for managing virtual memory.
     pm: litebox::mm::PageManager<Platform, { PAGE_SIZE }>,
     /// The filesystem implementation.
-    fs: LinuxFS,
+    fs: FS,
     /// The futex manager for handling futex operations.
     futex_manager: FutexManager<Platform>,
     /// The anonymous pipe implementation.
@@ -1162,11 +1157,11 @@ struct GlobalState {
     // TODO: better management of thread IDs
     next_thread_id: core::sync::atomic::AtomicI32,
     /// UNIX domain socket address table
-    unix_addr_table: litebox::sync::RwLock<Platform, syscalls::unix::UnixAddrTable>,
+    unix_addr_table: litebox::sync::RwLock<Platform, syscalls::unix::UnixAddrTable<FS>>,
 }
 
-struct Task {
-    global: Arc<GlobalState>,
+struct Task<FS: ShimFS> {
+    global: Arc<GlobalState<FS>>,
     wait_state: wait::WaitState,
     thread: syscalls::process::ThreadState,
     /// Process ID
@@ -1183,12 +1178,12 @@ struct Task {
     /// Filesystem state. `RefCell` to support `unshare` in the future.
     fs: RefCell<Arc<syscalls::file::FsState>>,
     /// File descriptors. `RefCell` to support `unshare` in the future.
-    files: RefCell<Arc<syscalls::file::FilesState>>,
+    files: RefCell<Arc<syscalls::file::FilesState<FS>>>,
     /// Signal state
     signals: syscalls::signal::SignalState,
 }
 
-impl Drop for Task {
+impl<FS: ShimFS> Drop for Task<FS> {
     fn drop(&mut self) {
         self.prepare_for_exit();
     }
@@ -1201,9 +1196,9 @@ mod test_utils {
     extern crate std;
     use super::*;
 
-    impl GlobalState {
+    impl<FS: ShimFS> GlobalState<FS> {
         /// Make a new task with default values for testing.
-        pub(crate) fn new_test_task(self: Arc<Self>) -> Task {
+        pub(crate) fn new_test_task(self: Arc<Self>) -> Task<FS> {
             let pid = self
                 .next_thread_id
                 .fetch_add(1, core::sync::atomic::Ordering::Relaxed);
@@ -1230,7 +1225,7 @@ mod test_utils {
         }
     }
 
-    impl Task {
+    impl<FS: ShimFS> Task<FS> {
         /// Returns a clone of this task with a new TID for testing.
         pub(crate) fn clone_for_test(&self) -> Option<Self> {
             let tid = self
@@ -1259,7 +1254,7 @@ mod test_utils {
         /// Panics if the test process is already terminating.
         pub(crate) fn spawn_clone_for_test<R>(
             &self,
-            f: impl 'static + Send + FnOnce(Task) -> R,
+            f: impl 'static + Send + FnOnce(Task<FS>) -> R,
         ) -> std::thread::JoinHandle<R>
         where
             R: 'static + Send,
diff --git a/litebox_shim_linux/src/loader/auxv.rs b/litebox_shim_linux/src/loader/auxv.rs
index a901453be..e23c4a62e 100644
--- a/litebox_shim_linux/src/loader/auxv.rs
+++ b/litebox_shim_linux/src/loader/auxv.rs
@@ -3,7 +3,7 @@
 
 //! Auxiliary vector support.
 
-use crate::Task;
+use crate::{ShimFS, Task};
 use litebox::platform::SystemInfoProvider as _;
 
 #[allow(non_camel_case_types)]
@@ -67,7 +67,7 @@ pub enum AuxKey {
 
 pub type AuxVec = alloc::collections::btree_map::BTreeMap<AuxKey, usize>;
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Initialize the auxiliary vector with user information and VDSO address.
     pub fn init_auxv(&self) -> AuxVec {
         let mut aux = AuxVec::new();
diff --git a/litebox_shim_linux/src/loader/elf.rs b/litebox_shim_linux/src/loader/elf.rs
index 254b5ec62..0d62030a8 100644
--- a/litebox_shim_linux/src/loader/elf.rs
+++ b/litebox_shim_linux/src/loader/elf.rs
@@ -19,16 +19,16 @@ use crate::{
 };
 
 use super::stack::UserStack;
-use crate::Task;
+use crate::{ShimFS, Task};
 
 // An opened elf file
-struct ElfFile<'a> {
-    task: &'a Task,
+struct ElfFile<'a, FS: ShimFS> {
+    task: &'a Task<FS>,
     fd: i32,
 }
 
-impl<'a> ElfFile<'a> {
-    fn new(task: &'a Task, path: impl litebox::path::Arg) -> Result<Self, Errno> {
+impl<'a, FS: ShimFS> ElfFile<'a, FS> {
+    fn new(task: &'a Task<FS>, path: impl litebox::path::Arg) -> Result<Self, Errno> {
         let fd = task
             .sys_open(path, OFlags::RDONLY, Mode::empty())?
             .reinterpret_as_signed();
@@ -36,13 +36,13 @@ impl<'a> ElfFile<'a> {
     }
 }
 
-impl Drop for ElfFile<'_> {
+impl<FS: ShimFS> Drop for ElfFile<'_, FS> {
     fn drop(&mut self) {
         self.task.sys_close(self.fd).expect("failed to close fd");
     }
 }
 
-impl litebox_common_linux::loader::ReadAt for &'_ ElfFile<'_> {
+impl<FS: ShimFS> litebox_common_linux::loader::ReadAt for &'_ ElfFile<'_, FS> {
     type Error = Errno;
 
     fn read_at(&mut self, mut offset: u64, mut buf: &mut [u8]) -> Result<(), Self::Error> {
@@ -68,7 +68,7 @@ impl litebox_common_linux::loader::ReadAt for &'_ ElfFile<'_> {
     }
 }
 
-impl litebox_common_linux::loader::MapMemory for ElfFile<'_> {
+impl<FS: ShimFS> litebox_common_linux::loader::MapMemory for ElfFile<'_, FS> {
     type Error = Errno;
 
     fn reserve(&mut self, len: usize, align: usize) -> Result<usize, Self::Error> {
@@ -156,19 +156,19 @@ pub struct ElfLoadInfo {
 }
 
 /// Loader for ELF files
-pub(crate) struct ElfLoader<'a> {
+pub(crate) struct ElfLoader<'a, FS: ShimFS> {
     path: &'a str,
-    main: FileAndParsed<'a>,
-    interp: Option<FileAndParsed<'a>>,
+    main: FileAndParsed<'a, FS>,
+    interp: Option<FileAndParsed<'a, FS>>,
 }
 
-struct FileAndParsed<'a> {
-    file: ElfFile<'a>,
+struct FileAndParsed<'a, FS: ShimFS> {
+    file: ElfFile<'a, FS>,
     parsed: ElfParsedFile,
 }
 
-impl<'a> FileAndParsed<'a> {
-    fn new(task: &'a Task, path: impl litebox::path::Arg) -> Result<Self, ElfLoaderError> {
+impl<'a, FS: ShimFS> FileAndParsed<'a, FS> {
+    fn new(task: &'a Task<FS>, path: impl litebox::path::Arg) -> Result<Self, ElfLoaderError> {
         let file = ElfFile::new(task, path).map_err(ElfLoaderError::OpenError)?;
         let mut parsed = litebox_common_linux::loader::ElfParsedFile::parse(&mut &file)
             .map_err(ElfLoaderError::ParseError)?;
@@ -177,9 +177,9 @@ impl<'a> FileAndParsed<'a> {
     }
 }
 
-impl<'a> ElfLoader<'a> {
+impl<'a, FS: ShimFS> ElfLoader<'a, FS> {
     /// Parses an ELF file from the given path.
-    pub fn new(task: &'a Task, path: &'a str) -> Result<Self, ElfLoaderError> {
+    pub fn new(task: &'a Task<FS>, path: &'a str) -> Result<Self, ElfLoaderError> {
         // Parse the main ELF file.
         let main = FileAndParsed::new(task, path)?;
 
diff --git a/litebox_shim_linux/src/syscalls/epoll.rs b/litebox_shim_linux/src/syscalls/epoll.rs
index 038ac11ec..c6f3ea07c 100644
--- a/litebox_shim_linux/src/syscalls/epoll.rs
+++ b/litebox_shim_linux/src/syscalls/epoll.rs
@@ -21,7 +21,7 @@ use litebox_common_linux::{EpollEvent, EpollOp, errno::Errno};
 use litebox_platform_multiplex::Platform;
 
 use super::file::FilesState;
-use crate::{Descriptor, GlobalState, StrongFd};
+use crate::{Descriptor, GlobalState, ShimFS, StrongFd};
 
 bitflags::bitflags! {
     /// Linux's epoll flags.
@@ -34,19 +34,19 @@ bitflags::bitflags! {
     }
 }
 
-pub(crate) enum EpollDescriptor {
+pub(crate) enum EpollDescriptor<FS: ShimFS> {
     Eventfd(Arc<super::eventfd::EventFile<Platform>>),
-    Epoll(Arc<super::epoll::EpollFile>),
-    File(Arc<crate::FileFd>),
+    Epoll(Arc<super::epoll::EpollFile<FS>>),
+    File(Arc<crate::FileFd<FS>>),
     Socket(Arc<super::net::SocketFd>),
     Pipe(Arc<litebox::pipes::PipeFd<Platform>>),
-    Unix(Arc<crate::syscalls::unix::UnixSocket>),
+    Unix(Arc<crate::syscalls::unix::UnixSocket<FS>>),
 }
 
-impl EpollDescriptor {
-    pub fn try_from(files: &FilesState, desc: &Descriptor) -> Result<Self, Errno> {
+impl<FS: ShimFS> EpollDescriptor<FS> {
+    pub fn try_from(files: &FilesState<FS>, desc: &Descriptor<FS>) -> Result<Self, Errno> {
         match desc {
-            Descriptor::LiteBoxRawFd(raw_fd) => match StrongFd::from_raw(files, *raw_fd)? {
+            Descriptor::LiteBoxRawFd(raw_fd) => match StrongFd::<FS>::from_raw(files, *raw_fd)? {
                 StrongFd::FileSystem(fd) => Ok(EpollDescriptor::File(fd)),
                 StrongFd::Network(fd) => Ok(EpollDescriptor::Socket(fd)),
                 StrongFd::Pipes(fd) => Ok(EpollDescriptor::Pipe(fd)),
@@ -58,17 +58,17 @@ impl EpollDescriptor {
     }
 }
 
-enum DescriptorRef {
+enum DescriptorRef<FS: ShimFS> {
     Eventfd(Weak<crate::syscalls::eventfd::EventFile<litebox_platform_multiplex::Platform>>),
-    Epoll(Weak<super::epoll::EpollFile>),
-    File(Weak<crate::FileFd>),
+    Epoll(Weak<super::epoll::EpollFile<FS>>),
+    File(Weak<crate::FileFd<FS>>),
     Socket(Weak<super::net::SocketFd>),
     Pipe(Weak<litebox::pipes::PipeFd<Platform>>),
-    Unix(Weak<crate::syscalls::unix::UnixSocket>),
+    Unix(Weak<crate::syscalls::unix::UnixSocket<FS>>),
 }
 
-impl DescriptorRef {
-    fn from(value: &EpollDescriptor) -> Self {
+impl<FS: ShimFS> DescriptorRef<FS> {
+    fn from(value: &EpollDescriptor<FS>) -> Self {
         match value {
             EpollDescriptor::Eventfd(file) => Self::Eventfd(Arc::downgrade(file)),
             EpollDescriptor::Epoll(file) => Self::Epoll(Arc::downgrade(file)),
@@ -79,7 +79,7 @@ impl DescriptorRef {
         }
     }
 
-    fn upgrade(&self) -> Option<EpollDescriptor> {
+    fn upgrade(&self) -> Option<EpollDescriptor<FS>> {
         match self {
             DescriptorRef::Eventfd(eventfd) => eventfd.upgrade().map(EpollDescriptor::Eventfd),
             DescriptorRef::Epoll(epoll) => epoll.upgrade().map(EpollDescriptor::Epoll),
@@ -91,12 +91,12 @@ impl DescriptorRef {
     }
 }
 
-impl EpollDescriptor {
+impl<FS: ShimFS> EpollDescriptor<FS> {
     /// Returns the interesting events now and monitors their occurrence in the future if the
     /// observer is provided.
     fn poll(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         mask: Events,
         observer: Option<Weak<dyn Observer<Events>>>,
     ) -> Option<Events> {
@@ -132,16 +132,16 @@ impl EpollDescriptor {
     }
 }
 
-pub(crate) struct EpollFile {
+pub(crate) struct EpollFile<FS: ShimFS> {
     interests: litebox::sync::Mutex<
         litebox_platform_multiplex::Platform,
-        BTreeMap<EpollEntryKey, alloc::sync::Arc<EpollEntry>>,
+        BTreeMap<EpollEntryKey, alloc::sync::Arc<EpollEntry<FS>>>,
     >,
-    ready: Arc<ReadySet>,
+    ready: Arc<ReadySet<FS>>,
     status: core::sync::atomic::AtomicU32,
 }
 
-impl EpollFile {
+impl<FS: ShimFS> EpollFile<FS> {
     pub(crate) fn new() -> Self {
         EpollFile {
             interests: litebox::sync::Mutex::new(BTreeMap::new()),
@@ -152,7 +152,7 @@ impl EpollFile {
 
     pub(crate) fn wait(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         cx: &WaitContext<'_, Platform>,
         maxevents: usize,
     ) -> Result<Vec<EpollEvent>, WaitError> {
@@ -172,10 +172,10 @@ impl EpollFile {
 
     pub(crate) fn epoll_ctl(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         op: EpollOp,
         fd: u32,
-        file: &EpollDescriptor,
+        file: &EpollDescriptor<FS>,
         event: Option<EpollEvent>,
     ) -> Result<(), Errno> {
         match op {
@@ -196,9 +196,9 @@ impl EpollFile {
 
     fn add_interest(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         fd: u32,
-        file: &EpollDescriptor,
+        file: &EpollDescriptor<FS>,
         event: EpollEvent,
     ) -> Result<(), Errno> {
         let mut interests = self.interests.lock();
@@ -233,9 +233,9 @@ impl EpollFile {
     #[expect(dead_code, reason = "currently unused, but might want to use soon")]
     fn mod_interest(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         fd: u32,
-        file: &EpollDescriptor,
+        file: &EpollDescriptor<FS>,
         event: EpollEvent,
     ) -> Result<(), Errno> {
         // EPOLLEXCLUSIVE is not allowed for a EPOLL_CTL_MOD operation
@@ -292,7 +292,7 @@ impl EpollFile {
 #[derive(PartialEq, Eq, PartialOrd, Ord)]
 struct EpollEntryKey(u32, usize);
 impl EpollEntryKey {
-    fn new(fd: u32, desc: &EpollDescriptor) -> Self {
+    fn new<FS: ShimFS>(fd: u32, desc: &EpollDescriptor<FS>) -> Self {
         let ptr = match desc {
             EpollDescriptor::Eventfd(file) => Arc::as_ptr(file).addr(),
             EpollDescriptor::Epoll(file) => Arc::as_ptr(file).addr(),
@@ -305,10 +305,10 @@ impl EpollEntryKey {
     }
 }
 
-struct EpollEntry {
-    desc: DescriptorRef,
+struct EpollEntry<FS: ShimFS> {
+    desc: DescriptorRef<FS>,
     inner: litebox::sync::Mutex<litebox_platform_multiplex::Platform, EpollEntryInner>,
-    ready: Arc<ReadySet>,
+    ready: Arc<ReadySet<FS>>,
     is_ready: AtomicBool,
     is_enabled: AtomicBool,
     weak_self: Weak<Self>,
@@ -320,13 +320,13 @@ struct EpollEntryInner {
     data: u64,
 }
 
-impl EpollEntry {
+impl<FS: ShimFS> EpollEntry<FS> {
     fn new(
-        desc: DescriptorRef,
+        desc: DescriptorRef<FS>,
         mask: Events,
         flags: EpollFlags,
         data: u64,
-        ready: Arc<ReadySet>,
+        ready: Arc<ReadySet<FS>>,
     ) -> Arc<Self> {
         Arc::new_cyclic(|weak_self| EpollEntry {
             desc,
@@ -338,7 +338,7 @@ impl EpollEntry {
         })
     }
 
-    fn poll(&self, global: &GlobalState) -> Option<(Option<EpollEvent>, bool)> {
+    fn poll(&self, global: &GlobalState<FS>) -> Option<(Option<EpollEvent>, bool)> {
         let file = self.desc.upgrade()?;
         let inner = self.inner.lock();
 
@@ -373,21 +373,21 @@ impl EpollEntry {
     }
 }
 
-impl Observer<Events> for EpollEntry {
+impl<FS: ShimFS> Observer<Events> for EpollEntry<FS> {
     fn on_events(&self, _events: &Events) {
         self.ready.push(self);
     }
 }
 
-struct ReadySet {
+struct ReadySet<FS: ShimFS> {
     entries: litebox::sync::Mutex<
         litebox_platform_multiplex::Platform,
-        VecDeque<alloc::sync::Weak<EpollEntry>>,
+        VecDeque<alloc::sync::Weak<EpollEntry<FS>>>,
     >,
     pollee: Pollee<Platform>,
 }
 
-impl ReadySet {
+impl<FS: ShimFS> ReadySet<FS> {
     fn new() -> Self {
         Self {
             entries: litebox::sync::Mutex::new(VecDeque::new()),
@@ -395,7 +395,7 @@ impl ReadySet {
         }
     }
 
-    fn push(&self, entry: &EpollEntry) {
+    fn push(&self, entry: &EpollEntry<FS>) {
         if !entry.is_enabled.load(core::sync::atomic::Ordering::Relaxed) {
             // the entry is disabled
             return;
@@ -412,7 +412,12 @@ impl ReadySet {
         self.pollee.notify_observers(Events::IN);
     }
 
-    fn pop_multiple(&self, global: &GlobalState, maxevents: usize, events: &mut Vec<EpollEvent>) {
+    fn pop_multiple(
+        &self,
+        global: &GlobalState<FS>,
+        maxevents: usize,
+        events: &mut Vec<EpollEvent>,
+    ) {
         let mut nums = self.entries.lock().len();
         while nums > 0 {
             nums -= 1;
@@ -495,10 +500,10 @@ impl PollSet {
         });
     }
 
-    fn scan_once(
+    fn scan_once<FS: ShimFS>(
         &mut self,
-        global: &GlobalState,
-        files: &FilesState,
+        global: &GlobalState<FS>,
+        files: &FilesState<FS>,
         waker: Option<&Waker<Platform>>,
     ) -> bool {
         let mut is_ready = false;
@@ -541,16 +546,16 @@ impl PollSet {
     }
 
     /// Scans the poll set for ready fds once.
-    pub fn scan(&mut self, global: &GlobalState, files: &FilesState) {
+    pub fn scan<FS: ShimFS>(&mut self, global: &GlobalState<FS>, files: &FilesState<FS>) {
         self.scan_once(global, files, None);
     }
 
     /// Waits for any of the fds in the poll set to become ready.
-    pub fn wait(
+    pub fn wait<FS: ShimFS>(
         &mut self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         cx: &WaitContext<'_, Platform>,
-        files: &FilesState,
+        files: &FilesState<FS>,
     ) -> Result<(), WaitError> {
         if self.scan_once(global, files, None) {
             return Ok(());
@@ -602,7 +607,7 @@ mod test {
 
     extern crate std;
 
-    fn setup_epoll() -> (crate::Task, EpollFile) {
+    fn setup_epoll() -> (crate::Task<crate::DefaultFS>, EpollFile<crate::DefaultFS>) {
         let task = crate::syscalls::tests::init_platform(None);
 
         let epoll = EpollFile::new();
diff --git a/litebox_shim_linux/src/syscalls/file.rs b/litebox_shim_linux/src/syscalls/file.rs
index 8c7283712..7e05ed22b 100644
--- a/litebox_shim_linux/src/syscalls/file.rs
+++ b/litebox_shim_linux/src/syscalls/file.rs
@@ -11,7 +11,7 @@ use alloc::{
 use litebox::{
     event::{Events, wait::WaitError},
     fd::{FdEnabledSubsystem, MetadataError, TypedFd},
-    fs::{FileSystem as _, Mode, OFlags, SeekWhence},
+    fs::{Mode, OFlags, SeekWhence},
     path,
     platform::{RawConstPointer, RawMutPointer},
     utils::{ReinterpretSignedExt as _, ReinterpretUnsignedExt as _, TruncateExt as _},
@@ -22,7 +22,7 @@ use litebox_common_linux::{
 };
 use litebox_platform_multiplex::Platform;
 
-use crate::{ConstPtr, Descriptor, Descriptors, GlobalState, MutPtr, Task};
+use crate::{ConstPtr, Descriptor, Descriptors, GlobalState, MutPtr, ShimFS, Task};
 use core::sync::atomic::Ordering;
 
 /// Task state shared by `CLONE_FS`.
@@ -51,12 +51,12 @@ impl FsState {
 }
 
 /// Task state shared by `CLONE_FILES`.
-pub(crate) struct FilesState {
-    pub file_descriptors: litebox::sync::RwLock<Platform, Descriptors>,
+pub(crate) struct FilesState<FS: ShimFS> {
+    pub file_descriptors: litebox::sync::RwLock<Platform, Descriptors<FS>>,
     pub raw_descriptor_store: litebox::sync::RwLock<Platform, litebox::fd::RawDescriptorStorage>,
 }
 
-impl FilesState {
+impl<FS: ShimFS> FilesState<FS> {
     pub fn new() -> Self {
         Self {
             file_descriptors: litebox::sync::RwLock::new(Descriptors::new()),
@@ -113,7 +113,7 @@ impl<P: path::Arg> FsPath<P> {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     fn get_umask(&self) -> Mode {
         self.fs.borrow().umask()
     }
@@ -376,7 +376,7 @@ pub(crate) fn try_into_whence(value: i16) -> Result<SeekWhence, i16> {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `lseek`
     pub fn sys_lseek(&self, fd: i32, offset: isize, whence: SeekWhence) -> Result<usize, Errno> {
         let Ok(fd) = u32::try_from(fd) else {
@@ -406,7 +406,7 @@ impl Task {
         self.global.fs.mkdir(pathname, mode).map_err(Errno::from)
     }
 
-    pub(crate) fn do_close(&self, desc: Descriptor) -> Result<(), Errno> {
+    pub(crate) fn do_close(&self, desc: Descriptor<FS>) -> Result<(), Errno> {
         let files = self.files.borrow();
         match desc {
             Descriptor::LiteBoxRawFd(raw_fd) => {
@@ -553,7 +553,7 @@ where
     Ok(total_written)
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `writev`
     pub fn sys_writev(
         &self,
@@ -690,8 +690,8 @@ impl Task {
     }
 }
 
-impl Descriptor {
-    fn stat(&self, task: &Task) -> Result<FileStat, Errno> {
+impl<FS: ShimFS> Descriptor<FS> {
+    fn stat(&self, task: &Task<FS>) -> Result<FileStat, Errno> {
         let fstat = match self {
             Descriptor::LiteBoxRawFd(raw_fd) => task
                 .files
@@ -798,13 +798,13 @@ impl Descriptor {
 
     pub(crate) fn get_file_descriptor_flags(
         &self,
-        global: &GlobalState,
-        files: &FilesState,
+        global: &GlobalState<FS>,
+        files: &FilesState<FS>,
     ) -> Result<FileDescriptorFlags, Errno> {
         // Currently, only one such flag is defined: FD_CLOEXEC, the close-on-exec flag.
         // See https://www.man7.org/linux/man-pages/man2/F_GETFD.2const.html
-        fn get_flags<S: FdEnabledSubsystem>(
-            global: &GlobalState,
+        fn get_flags<FS: ShimFS, S: FdEnabledSubsystem>(
+            global: &GlobalState<FS>,
             fd: &TypedFd<S>,
         ) -> FileDescriptorFlags {
             global
@@ -833,12 +833,12 @@ impl Descriptor {
     }
     fn set_file_descriptor_flags(
         &self,
-        global: &GlobalState,
-        files: &FilesState,
+        global: &GlobalState<FS>,
+        files: &FilesState<FS>,
         flags: FileDescriptorFlags,
     ) -> Result<(), Errno> {
-        fn set_flags<S: FdEnabledSubsystem>(
-            global: &GlobalState,
+        fn set_flags<FS: ShimFS, S: FdEnabledSubsystem>(
+            global: &GlobalState<FS>,
             fd: &TypedFd<S>,
             flags: FileDescriptorFlags,
         ) {
@@ -868,7 +868,7 @@ impl Descriptor {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     fn do_stat(&self, pathname: impl path::Arg, follow_symlink: bool) -> Result<FileStat, Errno> {
         let normalized_path = pathname.normalized()?;
         let path = if follow_symlink {
@@ -1182,7 +1182,7 @@ impl Task {
 
 const DEFAULT_PIPE_BUF_SIZE: usize = 1024 * 1024;
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `pipe2`
     pub fn sys_pipe2(&self, flags: OFlags) -> Result<(u32, u32), Errno> {
         let (pipe_flags, cloexec) = {
@@ -1293,7 +1293,7 @@ impl Task {
         }
     }
 
-    fn is_stdio(&self, fd: &TypedFd<crate::LinuxFS>) -> Result<bool, Errno> {
+    fn is_stdio(&self, fd: &TypedFd<FS>) -> Result<bool, Errno> {
         match self.global.fs.fd_file_status(fd) {
             Ok(status) => {
                 // See https://www.kernel.org/doc/Documentation/admin-guide/devices.txt
@@ -1729,17 +1729,17 @@ impl Task {
         Ok(count)
     }
 
-    fn do_dup(&self, file: &Descriptor, flags: OFlags) -> Result<Descriptor, Errno> {
+    fn do_dup(&self, file: &Descriptor<FS>, flags: OFlags) -> Result<Descriptor<FS>, Errno> {
         let close_on_exec = flags.contains(OFlags::CLOEXEC);
         let files = self.files.borrow();
         match file {
             Descriptor::LiteBoxRawFd(raw_fd) => {
-                fn dup<S: FdEnabledSubsystem>(
-                    global: &GlobalState,
-                    files: &FilesState,
+                fn dup<FS: ShimFS, S: FdEnabledSubsystem>(
+                    global: &GlobalState<FS>,
+                    files: &FilesState<FS>,
                     fd: &TypedFd<S>,
                     close_on_exec: bool,
-                ) -> Result<Descriptor, Errno> {
+                ) -> Result<Descriptor<FS>, Errno> {
                     let mut dt = global.litebox.descriptor_table_mut();
                     let fd: TypedFd<_> = dt.duplicate(fd).ok_or(Errno::EBADF)?;
                     if close_on_exec {
@@ -1843,7 +1843,7 @@ struct Diroff(usize);
 const DIRENT_STRUCT_BYTES_WITHOUT_NAME: usize =
     core::mem::offset_of!(litebox_common_linux::LinuxDirent64, __name);
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `getdents64`
     pub(crate) fn sys_getdirent64(
         &self,
diff --git a/litebox_shim_linux/src/syscalls/misc.rs b/litebox_shim_linux/src/syscalls/misc.rs
index bab87ad60..4e82dacd8 100644
--- a/litebox_shim_linux/src/syscalls/misc.rs
+++ b/litebox_shim_linux/src/syscalls/misc.rs
@@ -5,14 +5,14 @@
 //!
 //! Examples of syscalls handled here include `getrandom`, `uname`, and similar operations.
 
-use crate::Task;
+use crate::{ShimFS, Task};
 use litebox::{
     platform::{Instant as _, RawConstPointer as _, RawMutPointer as _, TimeProvider as _},
     utils::TruncateExt as _,
 };
 use litebox_common_linux::errno::Errno;
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `getrandom`.
     pub(crate) fn sys_getrandom(
         &self,
@@ -67,7 +67,7 @@ const SYS_INFO: litebox_common_linux::Utsname = litebox_common_linux::Utsname {
     domainname: to_fixed_size_array::<65>(""),
 };
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `uname`.
     pub(crate) fn sys_uname(
         &self,
@@ -108,7 +108,7 @@ const _LINUX_CAPABILITY_VERSION_1: u32 = 0x19980330;
 const _LINUX_CAPABILITY_VERSION_2: u32 = 0x20071026; /* deprecated - use v3 */
 const _LINUX_CAPABILITY_VERSION_3: u32 = 0x20080522;
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `capget`.
     ///
     /// Note we don't support capabilities in LiteBox, so this returns empty capabilities.
diff --git a/litebox_shim_linux/src/syscalls/mm.rs b/litebox_shim_linux/src/syscalls/mm.rs
index 8743d8c53..3f541b523 100644
--- a/litebox_shim_linux/src/syscalls/mm.rs
+++ b/litebox_shim_linux/src/syscalls/mm.rs
@@ -11,6 +11,7 @@ use litebox::{
 use litebox_common_linux::{MRemapFlags, MapFlags, ProtFlags, errno::Errno};
 
 use crate::MutPtr;
+use crate::ShimFS;
 use crate::Task;
 
 #[inline]
@@ -29,7 +30,7 @@ fn align_down(addr: usize, align: usize) -> usize {
     addr & !(align - 1)
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     #[inline]
     fn do_mmap(
         &self,
diff --git a/litebox_shim_linux/src/syscalls/net.rs b/litebox_shim_linux/src/syscalls/net.rs
index 2617afd5a..5f266228f 100644
--- a/litebox_shim_linux/src/syscalls/net.rs
+++ b/litebox_shim_linux/src/syscalls/net.rs
@@ -34,7 +34,7 @@ use litebox_common_linux::{
 use zerocopy::{FromBytes, IntoBytes};
 
 use crate::{ConstPtr, Descriptor, MutPtr};
-use crate::{GlobalState, Task};
+use crate::{GlobalState, ShimFS, Task};
 use crate::{
     Platform,
     syscalls::unix::{CSockUnixAddr, UnixSocket, UnixSocketAddr},
@@ -56,7 +56,7 @@ macro_rules! convert_flags {
 
 pub(super) type SocketFd = litebox::net::SocketFd<Platform>;
 
-impl super::file::FilesState {
+impl<FS: ShimFS> super::file::FilesState<FS> {
     fn with_socket_fd<R>(
         &self,
         raw_fd: usize,
@@ -87,7 +87,7 @@ impl super::file::FilesState {
         &self,
         sockfd: u32,
         inet_op: impl FnOnce(&SocketFd) -> Result<R, Errno>,
-        unix_op: impl FnOnce(Arc<UnixSocket>) -> Result<R, Errno>,
+        unix_op: impl FnOnce(Arc<UnixSocket<FS>>) -> Result<R, Errno>,
     ) -> Result<R, Errno> {
         let file_table = self.file_descriptors.read();
         match file_table.get_fd(sockfd).ok_or(Errno::EBADF)? {
@@ -191,7 +191,7 @@ pub(super) enum SocketOptionValue {
 /// so that they can access `net` and the litebox descriptor table. This might
 /// change if the nature of the litebox descriptor table changes, or if network
 /// namespaces are implemented.
-impl GlobalState {
+impl<FS: ShimFS> GlobalState<FS> {
     fn initialize_socket(
         &self,
         fd: &SocketFd,
@@ -900,7 +900,7 @@ fn parse_type_and_flags(type_and_flags: u32) -> Result<(SockType, SockFlags), Er
     Ok((ty, flags))
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `socket`
     pub(crate) fn sys_socket(
         &self,
@@ -1167,7 +1167,7 @@ pub(crate) fn write_sockaddr_to_user(
     addrlen.write_at_offset(0, len).ok_or(Errno::EFAULT)
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `accept`
     pub(crate) fn sys_accept(
         &self,
@@ -1660,7 +1660,7 @@ impl Task {
 }
 
 #[cfg(target_arch = "x86")]
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     pub(crate) fn sys_socketcall(&self, call: i32, args: ConstPtr<usize>) -> Result<usize, Errno> {
         use crate::ToSyscallResult;
         use litebox_common_linux::SocketcallType;
@@ -1856,7 +1856,7 @@ mod tests {
     const SERVER_PORT: u16 = 8080;
     const CLIENT_PORT: u16 = 8081;
 
-    fn init_platform(tun_device_name: Option<&str>) -> crate::Task {
+    fn init_platform(tun_device_name: Option<&str>) -> crate::Task<crate::DefaultFS> {
         let task = crate::syscalls::tests::init_platform(tun_device_name);
         let global = task.global.clone();
         if tun_device_name.is_some() {
@@ -1877,12 +1877,17 @@ mod tests {
         task
     }
 
-    fn close_socket(task: &crate::Task, fd: u32) {
+    fn close_socket(task: &crate::Task<crate::DefaultFS>, fd: u32) {
         task.sys_close(i32::try_from(fd).unwrap())
             .expect("close socket failed");
     }
 
-    fn epoll_add(task: &crate::Task, epfd: i32, target_fd: u32, events: litebox::event::Events) {
+    fn epoll_add(
+        task: &crate::Task<crate::DefaultFS>,
+        epfd: i32,
+        target_fd: u32,
+        events: litebox::event::Events,
+    ) {
         let ev = litebox_common_linux::EpollEvent {
             events: events.bits(),
             data: u64::from(target_fd),
@@ -1899,7 +1904,7 @@ mod tests {
     }
 
     fn epoll_wait(
-        task: &crate::Task,
+        task: &crate::Task<crate::DefaultFS>,
         epfd: i32,
         events: &mut [litebox_common_linux::EpollEvent],
     ) -> usize {
@@ -1909,7 +1914,7 @@ mod tests {
     }
 
     fn test_tcp_socket_as_server(
-        task: &crate::Task,
+        task: &crate::Task<crate::DefaultFS>,
         ip: [u8; 4],
         port: u16,
         is_nonblocking: bool,
@@ -2482,11 +2487,15 @@ mod unix_tests {
 
     extern crate std;
 
-    fn create_unix_socket(task: &Task, ty: SockType, flags: SockFlags) -> u32 {
+    fn create_unix_socket(task: &Task<crate::DefaultFS>, ty: SockType, flags: SockFlags) -> u32 {
         task.do_socket(AddressFamily::UNIX, ty, flags, 0).unwrap()
     }
 
-    fn create_unix_server_socket(task: &Task, addr: &str, flags: SockFlags) -> Result<u32, Errno> {
+    fn create_unix_server_socket(
+        task: &Task<crate::DefaultFS>,
+        addr: &str,
+        flags: SockFlags,
+    ) -> Result<u32, Errno> {
         let server_fd = create_unix_socket(task, SockType::Stream, flags);
         task.do_bind(
             server_fd,
@@ -2496,12 +2505,12 @@ mod unix_tests {
         Ok(server_fd)
     }
 
-    fn close_socket(task: &crate::Task, fd: u32) {
+    fn close_socket(task: &crate::Task<crate::DefaultFS>, fd: u32) {
         task.sys_close(i32::try_from(fd).unwrap())
             .expect("close socket failed");
     }
 
-    fn ppoll(task: &Task, fd: u32, events: Events) {
+    fn ppoll(task: &Task<crate::DefaultFS>, fd: u32, events: Events) {
         let fd = i32::try_from(fd).unwrap();
         let mut pollfd = [litebox_common_linux::Pollfd {
             fd,
diff --git a/litebox_shim_linux/src/syscalls/process.rs b/litebox_shim_linux/src/syscalls/process.rs
index 4f0abf1e9..05e015244 100644
--- a/litebox_shim_linux/src/syscalls/process.rs
+++ b/litebox_shim_linux/src/syscalls/process.rs
@@ -3,7 +3,7 @@
 
 //! Process/thread related syscalls.
 
-use crate::{ConstPtr, MutPtr, Task};
+use crate::{ConstPtr, MutPtr, ShimFS, Task};
 use alloc::boxed::Box;
 use alloc::collections::btree_map::BTreeMap;
 use alloc::sync::Arc;
@@ -228,7 +228,7 @@ impl Process {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Updates the process exit status for a thread exit.
     fn exit_thread(&self, code: i8) {
         let mut inner = self.thread.process.inner.lock();
@@ -320,7 +320,7 @@ pub(crate) struct Credentials {
     pub egid: u32,
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     pub(crate) fn process(&self) -> &Arc<Process> {
         &self.thread.process
     }
@@ -499,7 +499,7 @@ fn wake_robust_list(
     Ok(())
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Called when the task is exiting.
     pub(crate) fn prepare_for_exit(&mut self) {
         self.thread.detach_from_process();
@@ -547,12 +547,12 @@ type ThreadLocalDescriptor = MutPtr<u8>;
 #[cfg(target_arch = "x86")]
 type ThreadLocalDescriptor = litebox_common_linux::UserDesc;
 
-struct NewThreadArgs {
+struct NewThreadArgs<FS: ShimFS> {
     /// Task struct that maintains all per-thread data
-    task: Task,
+    task: Task<FS>,
 }
 
-impl litebox::shim::InitThread for NewThreadArgs {
+impl<FS: ShimFS> litebox::shim::InitThread for NewThreadArgs<FS> {
     type ExecutionContext = litebox_common_linux::PtRegs;
 
     fn init(
@@ -568,7 +568,7 @@ impl litebox::shim::InitThread for NewThreadArgs {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     pub(crate) fn sys_clone(
         &self,
         ctx: &litebox_common_linux::PtRegs,
@@ -853,7 +853,7 @@ impl ResourceLimits {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Get resource limits, and optionally set new limits.
     pub(crate) fn do_prlimit(
         &self,
@@ -1189,7 +1189,7 @@ impl CpuSet {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `sched_getaffinity`.
     ///
     /// Note this is a dummy implementation that always returns the same CPU set
@@ -1200,7 +1200,7 @@ impl Task {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `futex`
     pub(crate) fn sys_futex(
         &self,
@@ -1276,7 +1276,7 @@ impl Task {
 const MAX_VEC: usize = 4096; // limit count
 const MAX_TOTAL_BYTES: usize = 256 * 1024; // size cap
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Handle syscall `execve`.
     pub(crate) fn sys_execve(
         &self,
@@ -1377,7 +1377,7 @@ impl Task {
     /// to start executing it.
     pub(crate) fn load_program(
         &self,
-        mut loader: crate::loader::elf::ElfLoader<'_>,
+        mut loader: crate::loader::elf::ElfLoader<'_, FS>,
         argv: Vec<alloc::ffi::CString>,
         mut envp: Vec<alloc::ffi::CString>,
     ) -> Result<(), crate::loader::elf::ElfLoaderError> {
diff --git a/litebox_shim_linux/src/syscalls/signal/mod.rs b/litebox_shim_linux/src/syscalls/signal/mod.rs
index a48b98dfa..560431d26 100644
--- a/litebox_shim_linux/src/syscalls/signal/mod.rs
+++ b/litebox_shim_linux/src/syscalls/signal/mod.rs
@@ -16,7 +16,7 @@ use x86_64 as arch;
 use zerocopy::FromZeros;
 
 use crate::syscalls::process::ExitStatus;
-use crate::{ConstPtr, MutPtr, Task};
+use crate::{ConstPtr, MutPtr, ShimFS, Task};
 use alloc::collections::vec_deque::VecDeque;
 use alloc::sync::Arc;
 use core::cell::{Cell, RefCell};
@@ -378,7 +378,7 @@ impl SignalState {
 /// A fault when delivering a signal.
 struct DeliverFault;
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     pub(crate) fn sys_rt_sigprocmask(
         &self,
         how: SigmaskHow,
diff --git a/litebox_shim_linux/src/syscalls/signal/x86.rs b/litebox_shim_linux/src/syscalls/signal/x86.rs
index 34c6872dc..07da741d9 100644
--- a/litebox_shim_linux/src/syscalls/signal/x86.rs
+++ b/litebox_shim_linux/src/syscalls/signal/x86.rs
@@ -39,7 +39,7 @@ struct SignalFrameRt {
     ucontext: Ucontext,
 }
 
-impl Task {
+impl<FS: crate::ShimFS> Task<FS> {
     /// Legacy signal return syscall implementation for x86.
     pub(crate) fn sys_sigreturn(&self, ctx: &mut PtRegs) -> Result<usize, Errno> {
         let lctx_addr = ctx.esp.wrapping_sub(8);
diff --git a/litebox_shim_linux/src/syscalls/tests.rs b/litebox_shim_linux/src/syscalls/tests.rs
index e6c7e95c5..124454ab5 100644
--- a/litebox_shim_linux/src/syscalls/tests.rs
+++ b/litebox_shim_linux/src/syscalls/tests.rs
@@ -17,7 +17,7 @@ const TEST_TAR_FILE: &[u8] = include_bytes!("../../../litebox/src/fs/test.tar");
     not(target_os = "linux"),
     expect(unused_variables, reason = "ignored parameter on non-linux platforms")
 )]
-pub(crate) fn init_platform(tun_device_name: Option<&str>) -> crate::Task {
+pub(crate) fn init_platform(tun_device_name: Option<&str>) -> crate::Task<crate::DefaultFS> {
     static PLATFORM_INIT: std::sync::Once = std::sync::Once::new();
     PLATFORM_INIT.call_once(|| {
         #[cfg(target_os = "linux")]
diff --git a/litebox_shim_linux/src/syscalls/unix.rs b/litebox_shim_linux/src/syscalls/unix.rs
index d1959eb2a..9395bf7d1 100644
--- a/litebox_shim_linux/src/syscalls/unix.rs
+++ b/litebox_shim_linux/src/syscalls/unix.rs
@@ -20,7 +20,7 @@ use litebox::{
         polling::{Pollee, TryOpError},
         wait::WaitContext,
     },
-    fs::{FileSystem, Mode, OFlags, errors::OpenError},
+    fs::{Mode, OFlags, errors::OpenError},
     sync::{Mutex, RwLock},
     utils::TruncateExt as _,
 };
@@ -30,7 +30,7 @@ use litebox_common_linux::{
 };
 
 use crate::{
-    ConstPtr, FileFd, GlobalState, MutPtr, Task,
+    ConstPtr, FileFd, GlobalState, MutPtr, ShimFS, Task,
     channel::{Channel, ReadEnd, WriteEnd},
     syscalls::net::{SocketOptionValue, SocketOptions},
 };
@@ -61,8 +61,8 @@ pub(crate) enum UnixSocketAddr {
 /// For path-based sockets, this includes a file descriptor to ensure
 /// the socket file remains accessible. The file is automatically closed
 /// when this structure is dropped.
-enum UnixBoundSocketAddr {
-    Path((String, FileFd, Arc<GlobalState>)),
+enum UnixBoundSocketAddr<FS: ShimFS> {
+    Path((String, FileFd<FS>, Arc<GlobalState<FS>>)),
     Abstract(Vec<u8>),
 }
 
@@ -94,7 +94,11 @@ impl UnixSocketAddr {
     ///
     /// Returns an error if the address cannot be bound (e.g., file doesn't exist,
     /// permission denied).
-    fn bind(self, task: &Task, is_server: bool) -> Result<UnixBoundSocketAddr, Errno> {
+    fn bind<FS: ShimFS>(
+        self,
+        task: &Task<FS>,
+        is_server: bool,
+    ) -> Result<UnixBoundSocketAddr<FS>, Errno> {
         match self {
             UnixSocketAddr::Path(path) => {
                 let flags = if is_server {
@@ -139,7 +143,7 @@ impl UnixSocketAddr {
     }
 }
 
-impl UnixBoundSocketAddr {
+impl<FS: ShimFS> UnixBoundSocketAddr<FS> {
     /// Converts this bound address to a key for the global address table.
     fn to_key(&self) -> UnixSocketAddrKey {
         match self {
@@ -149,7 +153,7 @@ impl UnixBoundSocketAddr {
     }
 }
 
-impl Drop for UnixBoundSocketAddr {
+impl<FS: ShimFS> Drop for UnixBoundSocketAddr<FS> {
     fn drop(&mut self) {
         match self {
             Self::Path((_, file, global)) => {
@@ -160,8 +164,8 @@ impl Drop for UnixBoundSocketAddr {
     }
 }
 
-impl From<&UnixBoundSocketAddr> for UnixSocketAddr {
-    fn from(addr: &UnixBoundSocketAddr) -> Self {
+impl<FS: ShimFS> From<&UnixBoundSocketAddr<FS>> for UnixSocketAddr {
+    fn from(addr: &UnixBoundSocketAddr<FS>) -> Self {
         match addr {
             UnixBoundSocketAddr::Path((path, ..)) => UnixSocketAddr::Path(path.clone()),
             UnixBoundSocketAddr::Abstract(data) => UnixSocketAddr::Abstract(data.clone()),
@@ -173,13 +177,13 @@ impl From<&UnixBoundSocketAddr> for UnixSocketAddr {
 ///
 /// This is the state immediately after socket creation, before the socket
 /// has been connected, or put into listening mode.
-struct UnixInitStream {
+struct UnixInitStream<FS: ShimFS> {
     /// Optional bound address for this socket
-    addr: Option<UnixBoundSocketAddr>,
+    addr: Option<UnixBoundSocketAddr<FS>>,
     pollee: Pollee<crate::Platform>,
 }
 
-impl UnixInitStream {
+impl<FS: ShimFS> UnixInitStream<FS> {
     fn new() -> Self {
         Self {
             addr: None,
@@ -188,7 +192,7 @@ impl UnixInitStream {
     }
 
     /// Binds this socket to the given address.
-    fn bind(&mut self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    fn bind(&mut self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         if self.addr.is_some() && !addr.is_unnamed() {
             return Err(Errno::EINVAL);
         }
@@ -207,8 +211,8 @@ impl UnixInitStream {
     fn listen(
         self,
         backlog: u16,
-        global: &Arc<GlobalState>,
-    ) -> Result<UnixListenStream, (Self, Errno)> {
+        global: &Arc<GlobalState<FS>>,
+    ) -> Result<UnixListenStream<FS>, (Self, Errno)> {
         let Some(addr) = self.addr else {
             return Err((self, Errno::EINVAL));
         };
@@ -227,8 +231,8 @@ impl UnixInitStream {
     /// Converts this initial socket into a connected stream pair.
     fn into_connected(
         self,
-        peer_addr: Arc<UnixBoundSocketAddr>,
-    ) -> (UnixConnectedStream, UnixConnectedStream) {
+        peer_addr: Arc<UnixBoundSocketAddr<FS>>,
+    ) -> (UnixConnectedStream<FS>, UnixConnectedStream<FS>) {
         let UnixInitStream { addr, pollee } = self;
         UnixConnectedStream::new_pair(addr.map(Arc::new), Some(Arc::new(pollee)), Some(peer_addr))
     }
@@ -237,18 +241,18 @@ impl UnixInitStream {
 /// Connection backlog for a listening Unix socket.
 ///
 /// Manages the queue of pending connections and the maximum backlog limit.
-struct Backlog {
+struct Backlog<FS: ShimFS> {
     /// The address this socket is listening on
-    addr: Arc<UnixBoundSocketAddr>,
+    addr: Arc<UnixBoundSocketAddr<FS>>,
     /// Maximum number of pending connections
     limit: AtomicU16,
     /// Queue of pending connections (None when shut down)
-    sockets: Mutex<crate::Platform, Option<VecDeque<UnixConnectedStream>>>,
+    sockets: Mutex<crate::Platform, Option<VecDeque<UnixConnectedStream<FS>>>>,
     pollee: Pollee<crate::Platform>,
 }
 
-impl Backlog {
-    fn new(addr: UnixBoundSocketAddr, backlog: u16, pollee: Pollee<crate::Platform>) -> Self {
+impl<FS: ShimFS> Backlog<FS> {
+    fn new(addr: UnixBoundSocketAddr<FS>, backlog: u16, pollee: Pollee<crate::Platform>) -> Self {
         Self {
             addr: Arc::new(addr),
             limit: AtomicU16::new(backlog),
@@ -265,8 +269,8 @@ impl Backlog {
     /// Attempts to establish a connection without blocking.
     fn try_connect(
         &self,
-        init: UnixInitStream,
-    ) -> Result<UnixConnectedStream, (UnixInitStream, Errno)> {
+        init: UnixInitStream<FS>,
+    ) -> Result<UnixConnectedStream<FS>, (UnixInitStream<FS>, Errno)> {
         let mut sockets = self.sockets.lock();
         let Some(sockets) = &mut *sockets else {
             // the server socket is shutdown
@@ -286,7 +290,7 @@ impl Backlog {
     }
 
     /// Attempts to accept a pending connection without blocking.
-    fn try_accept(&self) -> Result<UnixConnectedStream, TryOpError<Errno>> {
+    fn try_accept(&self) -> Result<UnixConnectedStream<FS>, TryOpError<Errno>> {
         let mut sockets = self.sockets.lock();
         let Some(sockets) = &mut *sockets else {
             // the server socket is shutdown
@@ -325,12 +329,12 @@ impl Backlog {
 }
 
 /// Represents a Unix stream socket in listening state.
-struct UnixListenStream {
-    backlog: Arc<Backlog>,
-    global: Arc<GlobalState>,
+struct UnixListenStream<FS: ShimFS> {
+    backlog: Arc<Backlog<FS>>,
+    global: Arc<GlobalState<FS>>,
 }
 
-impl UnixListenStream {
+impl<FS: ShimFS> UnixListenStream<FS> {
     /// Updates the maximum backlog size for pending connections.
     fn listen(&self, backlog: u16) {
         self.backlog.set_backlog(backlog);
@@ -345,12 +349,12 @@ impl UnixListenStream {
     }
 
     /// Returns the local address this socket is bound to.
-    fn get_local_addr(&self) -> &UnixBoundSocketAddr {
+    fn get_local_addr(&self) -> &UnixBoundSocketAddr<FS> {
         self.backlog.addr.as_ref()
     }
 }
 
-impl Drop for UnixListenStream {
+impl<FS: ShimFS> Drop for UnixListenStream<FS> {
     fn drop(&mut self) {
         self.backlog.shutdown();
 
@@ -366,18 +370,18 @@ impl Drop for UnixListenStream {
 }
 
 /// Tracks the local and peer addresses for a connected socket.
-struct AddrView {
-    addr: Option<Arc<UnixBoundSocketAddr>>,
-    peer: Option<Arc<UnixBoundSocketAddr>>,
+struct AddrView<FS: ShimFS> {
+    addr: Option<Arc<UnixBoundSocketAddr<FS>>>,
+    peer: Option<Arc<UnixBoundSocketAddr<FS>>>,
 }
 
-impl AddrView {
+impl<FS: ShimFS> AddrView<FS> {
     /// Creates a pair of address views for two connected sockets.
     ///
     /// The local address of one becomes the peer address of the other.
     fn new_pair(
-        addr: Option<Arc<UnixBoundSocketAddr>>,
-        peer: Option<Arc<UnixBoundSocketAddr>>,
+        addr: Option<Arc<UnixBoundSocketAddr<FS>>>,
+        peer: Option<Arc<UnixBoundSocketAddr<FS>>>,
     ) -> (Self, Self) {
         let first = Self {
             addr: addr.clone(),
@@ -391,12 +395,12 @@ impl AddrView {
     }
 
     /// Returns the local address, if available.
-    fn get_local_addr(&self) -> Option<&UnixBoundSocketAddr> {
+    fn get_local_addr(&self) -> Option<&UnixBoundSocketAddr<FS>> {
         self.addr.as_deref()
     }
 
     /// Returns the peer address, if available.
-    fn get_peer_addr(&self) -> Option<&UnixBoundSocketAddr> {
+    fn get_peer_addr(&self) -> Option<&UnixBoundSocketAddr<FS>> {
         self.peer.as_deref()
     }
 }
@@ -409,8 +413,8 @@ struct Message {
 }
 
 /// Represents a connected Unix stream socket.
-struct UnixConnectedStream {
-    addr: AddrView,
+struct UnixConnectedStream<FS: ShimFS> {
+    addr: AddrView<FS>,
     /// The read end of the local socket's channel for receiving messages.
     recv_channel: crate::channel::ReadEnd<Message>,
     /// The write end of the connected peer socket for sending messages.
@@ -419,12 +423,12 @@ struct UnixConnectedStream {
 }
 
 const UNIX_BUF_SIZE: usize = 65536;
-impl UnixConnectedStream {
+impl<FS: ShimFS> UnixConnectedStream<FS> {
     /// Creates a pair of connected Unix stream sockets.
     fn new_pair(
-        addr: Option<Arc<UnixBoundSocketAddr>>,
+        addr: Option<Arc<UnixBoundSocketAddr<FS>>>,
         pollee: Option<Arc<Pollee<crate::Platform>>>,
-        peer: Option<Arc<UnixBoundSocketAddr>>,
+        peer: Option<Arc<UnixBoundSocketAddr<FS>>>,
     ) -> (Self, Self) {
         let (addr1, addr2) = AddrView::new_pair(addr, peer);
         let pollee1 = pollee.unwrap_or(Arc::new(Pollee::new()));
@@ -519,20 +523,20 @@ impl UnixConnectedStream {
     }
 }
 
-enum UnixStreamState {
-    Init(UnixInitStream),
-    Listen(UnixListenStream),
-    Connected(UnixConnectedStream),
+enum UnixStreamState<FS: ShimFS> {
+    Init(UnixInitStream<FS>),
+    Listen(UnixListenStream<FS>),
+    Connected(UnixConnectedStream<FS>),
 }
 
-impl UnixStreamState {
-    fn connected(&self) -> Option<&UnixConnectedStream> {
+impl<FS: ShimFS> UnixStreamState<FS> {
+    fn connected(&self) -> Option<&UnixConnectedStream<FS>> {
         match self {
             UnixStreamState::Connected(conn) => Some(conn),
             _ => None,
         }
     }
-    fn listen(&self) -> Option<&UnixListenStream> {
+    fn listen(&self) -> Option<&UnixListenStream<FS>> {
         match self {
             UnixStreamState::Listen(listen) => Some(listen),
             _ => None,
@@ -540,12 +544,12 @@ impl UnixStreamState {
     }
 }
 
-struct UnixStream {
-    state: RwLock<crate::Platform, Option<UnixStreamState>>,
+struct UnixStream<FS: ShimFS> {
+    state: RwLock<crate::Platform, Option<UnixStreamState<FS>>>,
 }
 
-impl UnixStream {
-    fn new(state: UnixStreamState) -> Self {
+impl<FS: ShimFS> UnixStream<FS> {
+    fn new(state: UnixStreamState<FS>) -> Self {
         Self {
             state: litebox::sync::RwLock::new(Some(state)),
         }
@@ -553,7 +557,7 @@ impl UnixStream {
 
     fn with_state_ref<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(&UnixStreamState) -> R,
+        F: FnOnce(&UnixStreamState<FS>) -> R,
     {
         let old = self.state.read();
         f(old.as_ref().expect("state should never be None"))
@@ -561,7 +565,7 @@ impl UnixStream {
 
     fn with_state_mut_ref<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(&mut UnixStreamState) -> R,
+        F: FnOnce(&mut UnixStreamState<FS>) -> R,
     {
         let mut old = self.state.write();
         f(old.as_mut().expect("state should never be None"))
@@ -569,7 +573,7 @@ impl UnixStream {
 
     fn with_state<F, R>(&self, f: F) -> R
     where
-        F: FnOnce(UnixStreamState) -> (UnixStreamState, R),
+        F: FnOnce(UnixStreamState<FS>) -> (UnixStreamState<FS>, R),
     {
         let mut old = self.state.write();
         let (new, result) = f(old.take().expect("state should never be None"));
@@ -577,7 +581,7 @@ impl UnixStream {
         result
     }
 
-    fn bind(&self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    fn bind(&self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         self.with_state_mut_ref(|state| {
             match state {
                 UnixStreamState::Init(init) => init.bind(task, addr),
@@ -591,7 +595,7 @@ impl UnixStream {
         })
     }
 
-    fn listen(&self, backlog: u16, global: &Arc<GlobalState>) -> Result<(), Errno> {
+    fn listen(&self, backlog: u16, global: &Arc<GlobalState<FS>>) -> Result<(), Errno> {
         self.with_state(|state| {
             let ret = match state {
                 UnixStreamState::Init(init) => {
@@ -610,7 +614,7 @@ impl UnixStream {
         })
     }
 
-    fn lookup(&self, task: &Task, addr: &UnixSocketAddr) -> Result<Arc<Backlog>, Errno> {
+    fn lookup(&self, task: &Task<FS>, addr: &UnixSocketAddr) -> Result<Arc<Backlog<FS>>, Errno> {
         let guard = task.global.unix_addr_table.read();
         let Some(key) = addr.to_key() else {
             return Err(Errno::EINVAL);
@@ -623,7 +627,7 @@ impl UnixStream {
             UnixEntryInner::Datagram(_) => Err(Errno::EPROTOTYPE),
         }
     }
-    fn try_connect(&self, backlog: &Backlog) -> Result<(), TryOpError<Errno>> {
+    fn try_connect(&self, backlog: &Backlog<FS>) -> Result<(), TryOpError<Errno>> {
         self.with_state(|state| match state {
             UnixStreamState::Init(init) => match backlog.try_connect(init) {
                 Ok(connected) => (UnixStreamState::Connected(connected), Ok(())),
@@ -639,7 +643,7 @@ impl UnixStream {
     }
     fn connect(
         &self,
-        task: &Task,
+        task: &Task<FS>,
         addr: UnixSocketAddr,
         is_nonblocking: bool,
     ) -> Result<(), Errno> {
@@ -664,8 +668,8 @@ impl UnixStream {
         cx: &WaitContext<'_, crate::Platform>,
         mut peer: Option<&mut UnixSocketAddr>,
         is_nonblocking: bool,
-    ) -> Result<UnixSocketInner, Errno> {
-        let backlog = self.with_state_ref(|state| -> Result<Arc<Backlog>, Errno> {
+    ) -> Result<UnixSocketInner<FS>, Errno> {
+        let backlog = self.with_state_ref(|state| -> Result<Arc<Backlog<FS>>, Errno> {
             let listen = state.listen().ok_or(Errno::EINVAL)?;
             Ok(listen.backlog.clone())
         })?;
@@ -900,9 +904,9 @@ impl ReadEnd<DatagramMessage> {
     }
 }
 
-struct UnixDatagramInner {
+struct UnixDatagramInner<FS: ShimFS> {
     /// The local address this socket is bound to, if any.
-    addr: Option<(UnixBoundSocketAddr, Arc<GlobalState>)>,
+    addr: Option<(UnixBoundSocketAddr<FS>, Arc<GlobalState<FS>>)>,
     /// The read end of the local socket's channel for receiving messages.
     /// Set when the socket is bound via `bind` or `new_pair`.
     recv_channel: Option<ReadEnd<DatagramMessage>>,
@@ -912,11 +916,11 @@ struct UnixDatagramInner {
     pollee: Arc<Pollee<crate::Platform>>,
 }
 /// Represents a Unix datagram socket.
-struct UnixDatagram {
-    inner: RwLock<crate::Platform, UnixDatagramInner>,
+struct UnixDatagram<FS: ShimFS> {
+    inner: RwLock<crate::Platform, UnixDatagramInner<FS>>,
 }
 
-impl Drop for UnixDatagramInner {
+impl<FS: ShimFS> Drop for UnixDatagramInner<FS> {
     fn drop(&mut self) {
         if let Some((addr, global)) = self.addr.take() {
             let key = addr.to_key();
@@ -932,9 +936,9 @@ impl Drop for UnixDatagramInner {
     }
 }
 
-impl UnixDatagramInner {
+impl<FS: ShimFS> UnixDatagramInner<FS> {
     /// Binds this socket to the given address.
-    fn bind(&mut self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    fn bind(&mut self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         if self.addr.is_some() {
             return if addr.is_unnamed() {
                 Ok(())
@@ -960,7 +964,7 @@ impl UnixDatagramInner {
     }
 }
 
-impl UnixDatagram {
+impl<FS: ShimFS> UnixDatagram<FS> {
     fn new() -> Self {
         Self {
             inner: RwLock::new(UnixDatagramInner {
@@ -972,7 +976,7 @@ impl UnixDatagram {
         }
     }
 
-    fn new_pair() -> (UnixDatagram, UnixDatagram) {
+    fn new_pair() -> (UnixDatagram<FS>, UnixDatagram<FS>) {
         let pollee1 = Arc::new(Pollee::new());
         let pollee2 = Arc::new(Pollee::new());
         let (send_channel, recv_channel) =
@@ -1001,14 +1005,14 @@ impl UnixDatagram {
     }
 
     /// Binds this socket to the given address.
-    fn bind(&self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    fn bind(&self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         self.inner.write().bind(task, addr)
     }
 
     /// Looks up a socket address and returns its write endpoint.
     fn lookup(
         &self,
-        task: &Task,
+        task: &Task<FS>,
         addr: UnixSocketAddr,
     ) -> Result<WriteEnd<DatagramMessage>, Errno> {
         let guard = task.global.unix_addr_table.read();
@@ -1029,7 +1033,7 @@ impl UnixDatagram {
     /// Connects this socket to a default peer address.
     ///
     /// Subsequent sends without an address will use this peer.
-    fn connect(&self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    fn connect(&self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         self.inner.write().connected_send_channel = Some((self.lookup(task, addr.clone())?, addr));
         Ok(())
     }
@@ -1067,7 +1071,7 @@ impl UnixDatagram {
     /// connected peer (set via `connect()`).
     fn sendto(
         &self,
-        task: &Task,
+        task: &Task<FS>,
         timeout: Option<Duration>,
         buf: &[u8],
         is_nonblocking: bool,
@@ -1132,18 +1136,18 @@ impl UnixDatagram {
     }
 }
 
-enum UnixSocketInner {
-    Stream(UnixStream),
-    Datagram(UnixDatagram),
+enum UnixSocketInner<FS: ShimFS> {
+    Stream(UnixStream<FS>),
+    Datagram(UnixDatagram<FS>),
 }
-pub(crate) struct UnixSocket {
-    inner: UnixSocketInner,
+pub(crate) struct UnixSocket<FS: ShimFS> {
+    inner: UnixSocketInner<FS>,
     status: AtomicU32,
     options: Mutex<crate::Platform, SocketOptions>,
 }
 
-impl UnixSocket {
-    fn new_with_inner(inner: UnixSocketInner, flags: SockFlags) -> Self {
+impl<FS: ShimFS> UnixSocket<FS> {
+    fn new_with_inner(inner: UnixSocketInner<FS>, flags: SockFlags) -> Self {
         let mut status = OFlags::RDWR;
         status.set(OFlags::NONBLOCK, flags.contains(SockFlags::NONBLOCK));
         Self {
@@ -1167,21 +1171,21 @@ impl UnixSocket {
         Some(Self::new_with_inner(inner, flags))
     }
 
-    pub(super) fn bind(&self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    pub(super) fn bind(&self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         match &self.inner {
             UnixSocketInner::Stream(stream) => stream.bind(task, addr),
             UnixSocketInner::Datagram(datagram) => datagram.bind(task, addr),
         }
     }
 
-    pub(super) fn listen(&self, backlog: u16, global: &Arc<GlobalState>) -> Result<(), Errno> {
+    pub(super) fn listen(&self, backlog: u16, global: &Arc<GlobalState<FS>>) -> Result<(), Errno> {
         match &self.inner {
             UnixSocketInner::Stream(stream) => stream.listen(backlog, global),
             UnixSocketInner::Datagram(_) => Err(Errno::EOPNOTSUPP),
         }
     }
 
-    pub(super) fn connect(&self, task: &Task, addr: UnixSocketAddr) -> Result<(), Errno> {
+    pub(super) fn connect(&self, task: &Task<FS>, addr: UnixSocketAddr) -> Result<(), Errno> {
         match &self.inner {
             UnixSocketInner::Stream(stream) => {
                 stream.connect(task, addr, self.get_status().contains(OFlags::NONBLOCK))
@@ -1195,7 +1199,7 @@ impl UnixSocket {
         cx: &WaitContext<'_, crate::Platform>,
         flags: SockFlags,
         peer: Option<&mut UnixSocketAddr>,
-    ) -> Result<UnixSocket, Errno> {
+    ) -> Result<UnixSocket<FS>, Errno> {
         match &self.inner {
             UnixSocketInner::Stream(stream) => {
                 let accepted = stream.accept(
@@ -1212,7 +1216,7 @@ impl UnixSocket {
 
     pub(super) fn sendto(
         &self,
-        task: &Task,
+        task: &Task<FS>,
         buf: &[u8],
         flags: SendFlags,
         addr: Option<UnixSocketAddr>,
@@ -1287,7 +1291,7 @@ impl UnixSocket {
     pub(super) fn new_connected_pair(
         ty: SockType,
         flags: SockFlags,
-    ) -> Option<(UnixSocket, UnixSocket)> {
+    ) -> Option<(UnixSocket<FS>, UnixSocket<FS>)> {
         match ty {
             SockType::Stream => {
                 let (conn1, conn2) = UnixConnectedStream::new_pair(None, None, None);
@@ -1315,7 +1319,7 @@ impl UnixSocket {
 
     pub(super) fn setsockopt(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         optname: SocketOptionName,
         optval: ConstPtr<u8>,
         optlen: usize,
@@ -1372,7 +1376,7 @@ impl UnixSocket {
     }
     pub(super) fn getsockopt(
         &self,
-        global: &GlobalState,
+        global: &GlobalState<FS>,
         optname: SocketOptionName,
         optval: MutPtr<u8>,
         len: u32,
@@ -1444,7 +1448,7 @@ impl UnixSocket {
     super::common_functions_for_file_status!();
 }
 
-impl IOPollable for UnixSocket {
+impl<FS: ShimFS> IOPollable for UnixSocket<FS> {
     fn register_observer(
         &self,
         observer: Weak<dyn litebox::event::observer::Observer<Events>>,
@@ -1472,11 +1476,11 @@ impl IOPollable for UnixSocket {
     }
 }
 
-pub(crate) struct UnixEntry(UnixEntryInner);
-enum UnixEntryInner {
-    Stream(Arc<Backlog>),
+pub(crate) struct UnixEntry<FS: ShimFS>(UnixEntryInner<FS>);
+enum UnixEntryInner<FS: ShimFS> {
+    Stream(Arc<Backlog<FS>>),
     Datagram(WriteEnd<DatagramMessage>),
 }
 
 /// Type alias for the global Unix socket address table.
-pub(crate) type UnixAddrTable = BTreeMap<UnixSocketAddrKey, UnixEntry>;
+pub(crate) type UnixAddrTable<FS> = BTreeMap<UnixSocketAddrKey, UnixEntry<FS>>;
diff --git a/litebox_shim_linux/src/wait.rs b/litebox_shim_linux/src/wait.rs
index 568067945..43a35e742 100644
--- a/litebox_shim_linux/src/wait.rs
+++ b/litebox_shim_linux/src/wait.rs
@@ -6,7 +6,7 @@
 //! Use a dedicated module to prevent code from accidentally accessing
 //! `wait_state` without going through `wait_cx()`.
 
-use crate::{Platform, Task};
+use crate::{Platform, ShimFS, Task};
 
 pub(crate) struct WaitState(litebox::event::wait::WaitState<Platform>);
 
@@ -21,7 +21,7 @@ impl WaitState {
     }
 }
 
-impl Task {
+impl<FS: ShimFS> Task<FS> {
     /// Returns a wait context to use to perform interruptible waits.
     pub(crate) fn wait_cx(&self) -> litebox::event::wait::WaitContext<'_, Platform> {
         self.wait_state.0.context().with_check_for_interrupt(self)
@@ -43,7 +43,7 @@ impl Task {
     }
 }
 
-impl litebox::event::wait::CheckForInterrupt for Task {
+impl<FS: ShimFS> litebox::event::wait::CheckForInterrupt for Task<FS> {
     fn check_for_interrupt(&self) -> bool {
         self.is_exiting() || self.has_pending_signals()
     }