diff --git a/src/generate.sh b/src/generate.sh
index 3c2415bf977ca20c96b235918f99ed5ab201e3bb..31792a7216923eeae0a86e669366b8bbfae65592 100755
--- a/src/generate.sh
+++ b/src/generate.sh
@@ -2,14 +2,9 @@
 
 set -e
 
-echo "Generating SchemeMut from Scheme"
-sed 's/trait Scheme/trait SchemeMut/' scheme.rs \
-| sed 's/\&self/\&mut self/g' \
-> scheme_mut.rs
-
 echo "Generating SchemeBlock from Scheme"
 sed 's/trait Scheme/trait SchemeBlock/' scheme.rs \
-| sed 's/fn handle(\&self, packet: \&mut Packet)/fn handle(\&self, packet: \&Packet) -> Option<usize>/' \
+| sed 's/fn handle(\&mut self, packet: \&mut Packet)/fn handle(\&mut self, packet: \&Packet) -> Option<usize>/' \
 | sed 's/packet.a = Error::mux(res);/res.transpose().map(Error::mux)/' \
 | sed 's/\.map(|f| f\.bits())/\.map(|f| f.map(|f| f.bits()))/' \
 | sed 's/\.map(|o| o as usize)/.map(|o| o.map(|o| o as usize))/' \
@@ -17,8 +12,3 @@ sed 's/trait Scheme/trait SchemeBlock/' scheme.rs \
 | sed 's/Result<\([^>]\+\)>/Result<Option<\1>>/g' \
 | sed 's/convert_to_this_scheme/convert_to_this_scheme_block/g' \
 > scheme_block.rs
-
-echo "Generating SchemeBlockMut from SchemeBlock"
-sed 's/trait SchemeBlock/trait SchemeBlockMut/' scheme_block.rs \
-| sed 's/\&self/\&mut self/g' \
-> scheme_block_mut.rs
diff --git a/src/lib.rs b/src/lib.rs
index a11ce7500822d399f2fad8aa58c3ff439915bc8a..dbf5af2ff08685187175151e13073e9765a5415f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -13,15 +13,11 @@ use syscall::{
     EINTR, EINVAL, ENOENT, EOPNOTSUPP,
 };
 
-pub use self::scheme::Scheme;
 pub use self::scheme_block::SchemeBlock;
-pub use self::scheme_block_mut::SchemeBlockMut;
-pub use self::scheme_mut::SchemeMut;
+pub use self::scheme::Scheme;
 
-mod scheme;
 mod scheme_block;
-mod scheme_block_mut;
-mod scheme_mut;
+mod scheme;
 
 pub struct CallerCtx {
     pub pid: usize,
@@ -98,7 +94,7 @@ impl CallRequest {
 }
 
 impl CallRequest {
-    pub fn handle_scheme_mut(self, scheme: &mut impl SchemeMut) -> Response {
+    pub fn handle_scheme(self, scheme: &mut impl Scheme) -> Response {
         let Some(opcode) = Opcode::try_from_raw(self.inner.sqe.opcode) else {
             return Response::new(&self, Err(Error::new(EOPNOTSUPP)));
         };
@@ -236,7 +232,7 @@ impl CallRequest {
         Response::new(&self, result)
     }
     // TODO: Copy paste is bad, but ./generate.sh is worse
-    pub fn handle_scheme_block_mut(self, scheme: &mut impl SchemeBlockMut) -> Option<Response> {
+    pub fn handle_scheme_block(self, scheme: &mut impl SchemeBlock) -> Option<Response> {
         let Some(opcode) = Opcode::try_from_raw(self.inner.sqe.opcode) else {
             return Some(Response::new(&self, Err(Error::new(EOPNOTSUPP))));
         };
diff --git a/src/scheme.rs b/src/scheme.rs
index b86cd2a820cf401b0f69e00eab7174d38149e0bf..14e2e72fd72ddb4e025b4e53a8f0765855ee8fa3 100644
--- a/src/scheme.rs
+++ b/src/scheme.rs
@@ -4,56 +4,56 @@ use syscall::error::*;
 
 pub trait Scheme {
     #[allow(unused_variables)]
-    fn open(&self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<usize> {
+    fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<usize> {
         Err(Error::new(ENOENT))
     }
     #[allow(unused_variables)]
-    fn xopen(&self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
+    fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
         convert_to_this_scheme(self.open(path, flags, ctx.uid, ctx.gid))
     }
 
     #[allow(unused_variables)]
-    fn rmdir(&self, path: &str, uid: u32, gid: u32) -> Result<usize> {
+    fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
         Err(Error::new(ENOENT))
     }
 
     #[allow(unused_variables)]
-    fn unlink(&self, path: &str, uid: u32, gid: u32) -> Result<usize> {
+    fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
         Err(Error::new(ENOENT))
     }
 
     /* Resource operations */
     #[allow(unused_variables)]
-    fn dup(&self, old_id: usize, buf: &[u8]) -> Result<usize> {
+    fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn xdup(&self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<OpenResult> {
+    fn xdup(&mut self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<OpenResult> {
         convert_to_this_scheme(self.dup(old_id, buf))
     }
 
     #[allow(unused_variables)]
-    fn read_old(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+    fn read_old(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
         Err(Error::new(EBADF))
     }
     #[allow(unused_variables)]
-    fn read(&self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
+    fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
         self.read_old(id, buf)
     }
 
     #[allow(unused_variables)]
-    fn write_old(&self, id: usize, buf: &[u8]) -> Result<usize> {
+    fn write_old(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
         Err(Error::new(EBADF))
     }
     #[allow(unused_variables)]
-    fn write(&self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
+    fn write(&mut self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
         self.write_old(id, buf)
     }
 
     #[allow(unused_variables)]
     fn getdents<'buf>(
-        &self,
+        &mut self,
         id: usize,
         buf: DirentBuf<&'buf mut [u8]>,
         opaque_offset: u64,
@@ -62,77 +62,77 @@ pub trait Scheme {
     }
 
     #[allow(unused_variables)]
-    fn fsize(&self, id: usize) -> Result<u64> {
+    fn fsize(&mut self, id: usize) -> Result<u64> {
         Err(Error::new(ESPIPE))
     }
 
     #[allow(unused_variables)]
-    fn fchmod(&self, id: usize, mode: u16) -> Result<usize> {
+    fn fchmod(&mut self, id: usize, mode: u16) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fchown(&self, id: usize, uid: u32, gid: u32) -> Result<usize> {
+    fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
+    fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fevent(&self, id: usize, flags: EventFlags) -> Result<EventFlags> {
+    fn fevent(&mut self, id: usize, flags: EventFlags) -> Result<EventFlags> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
+    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn frename(&self, id: usize, path: &str, uid: u32, gid: u32) -> Result<usize> {
+    fn frename(&mut self, id: usize, path: &str, uid: u32, gid: u32) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
+    fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result<usize> {
+    fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fsync(&self, id: usize) -> Result<usize> {
+    fn fsync(&mut self, id: usize) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn ftruncate(&self, id: usize, len: usize) -> Result<usize> {
+    fn ftruncate(&mut self, id: usize, len: usize) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result<usize> {
+    fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn close(&self, id: usize) -> Result<usize> {
+    fn close(&mut self, id: usize) -> Result<usize> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn mmap_prep(&self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<usize> {
+    fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<usize> {
         Err(Error::new(EOPNOTSUPP))
     }
 
     #[allow(unused_variables)]
-    fn munmap(&self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<usize> {
+    fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<usize> {
         Err(Error::new(EOPNOTSUPP))
     }
 }
diff --git a/src/scheme_block.rs b/src/scheme_block.rs
index da312e6192324d80745ea5091718cccadbdbdb35..fa1e2945387c1997e9936b230786a7f6555d8abd 100644
--- a/src/scheme_block.rs
+++ b/src/scheme_block.rs
@@ -4,56 +4,56 @@ use syscall::error::*;
 
 pub trait SchemeBlock {
     #[allow(unused_variables)]
-    fn open(&self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
+    fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
         Err(Error::new(ENOENT))
     }
     #[allow(unused_variables)]
-    fn xopen(&self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<Option<OpenResult>> {
+    fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<Option<OpenResult>> {
         convert_to_this_scheme_block(self.open(path, flags, ctx.uid, ctx.gid))
     }
 
     #[allow(unused_variables)]
-    fn rmdir(&self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
+    fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
         Err(Error::new(ENOENT))
     }
 
     #[allow(unused_variables)]
-    fn unlink(&self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
+    fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
         Err(Error::new(ENOENT))
     }
 
     /* Resource operations */
     #[allow(unused_variables)]
-    fn dup(&self, old_id: usize, buf: &[u8]) -> Result<Option<usize>> {
+    fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn xdup(&self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<Option<OpenResult>> {
+    fn xdup(&mut self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<Option<OpenResult>> {
         convert_to_this_scheme_block(self.dup(old_id, buf))
     }
 
     #[allow(unused_variables)]
-    fn read_old(&self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
+    fn read_old(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
     #[allow(unused_variables)]
-    fn read(&self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
+    fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
         self.read_old(id, buf)
     }
 
     #[allow(unused_variables)]
-    fn write_old(&self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
+    fn write_old(&mut self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
     #[allow(unused_variables)]
-    fn write(&self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
+    fn write(&mut self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
         self.write_old(id, buf)
     }
 
     #[allow(unused_variables)]
     fn getdents<'buf>(
-        &self,
+        &mut self,
         id: usize,
         buf: DirentBuf<&'buf mut [u8]>,
         opaque_offset: u64,
@@ -62,77 +62,77 @@ pub trait SchemeBlock {
     }
 
     #[allow(unused_variables)]
-    fn fsize(&self, id: usize) -> Result<Option<u64>> {
+    fn fsize(&mut self, id: usize) -> Result<Option<u64>> {
         Err(Error::new(ESPIPE))
     }
 
     #[allow(unused_variables)]
-    fn fchmod(&self, id: usize, mode: u16) -> Result<Option<usize>> {
+    fn fchmod(&mut self, id: usize, mode: u16) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fchown(&self, id: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
+    fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result<Option<usize>> {
+    fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fevent(&self, id: usize, flags: EventFlags) -> Result<Option<EventFlags>> {
+    fn fevent(&mut self, id: usize, flags: EventFlags) -> Result<Option<EventFlags>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
+    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn frename(&self, id: usize, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
+    fn frename(&mut self, id: usize, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fstat(&self, id: usize, stat: &mut Stat) -> Result<Option<usize>> {
+    fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result<Option<usize>> {
+    fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn fsync(&self, id: usize) -> Result<Option<usize>> {
+    fn fsync(&mut self, id: usize) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn ftruncate(&self, id: usize, len: usize) -> Result<Option<usize>> {
+    fn ftruncate(&mut self, id: usize, len: usize) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result<Option<usize>> {
+    fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn close(&self, id: usize) -> Result<Option<usize>> {
+    fn close(&mut self, id: usize) -> Result<Option<usize>> {
         Err(Error::new(EBADF))
     }
 
     #[allow(unused_variables)]
-    fn mmap_prep(&self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<Option<usize>> {
+    fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<Option<usize>> {
         Err(Error::new(EOPNOTSUPP))
     }
 
     #[allow(unused_variables)]
-    fn munmap(&self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<Option<usize>> {
+    fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<Option<usize>> {
         Err(Error::new(EOPNOTSUPP))
     }
 }
diff --git a/src/scheme_block_mut.rs b/src/scheme_block_mut.rs
deleted file mode 100644
index 481515a3647e118b5af2b8a1861a06414743afc3..0000000000000000000000000000000000000000
--- a/src/scheme_block_mut.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use crate::*;
-use syscall::dirent::DirentBuf;
-use syscall::error::*;
-
-pub trait SchemeBlockMut {
-    #[allow(unused_variables)]
-    fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
-        Err(Error::new(ENOENT))
-    }
-    #[allow(unused_variables)]
-    fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<Option<OpenResult>> {
-        convert_to_this_scheme_block(self.open(path, flags, ctx.uid, ctx.gid))
-    }
-
-    #[allow(unused_variables)]
-    fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
-        Err(Error::new(ENOENT))
-    }
-
-    #[allow(unused_variables)]
-    fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
-        Err(Error::new(ENOENT))
-    }
-
-    /* Resource operations */
-    #[allow(unused_variables)]
-    fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn xdup(&mut self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<Option<OpenResult>> {
-        convert_to_this_scheme_block(self.dup(old_id, buf))
-    }
-
-    #[allow(unused_variables)]
-    fn read_old(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-    #[allow(unused_variables)]
-    fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
-        self.read_old(id, buf)
-    }
-
-    #[allow(unused_variables)]
-    fn write_old(&mut self, id: usize, buf: &[u8]) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-    #[allow(unused_variables)]
-    fn write(&mut self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<Option<usize>> {
-        self.write_old(id, buf)
-    }
-
-    #[allow(unused_variables)]
-    fn getdents<'buf>(
-        &mut self,
-        id: usize,
-        buf: DirentBuf<&'buf mut [u8]>,
-        opaque_offset: u64,
-    ) -> Result<Option<DirentBuf<&'buf mut [u8]>>> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-
-    #[allow(unused_variables)]
-    fn fsize(&mut self, id: usize) -> Result<Option<u64>> {
-        Err(Error::new(ESPIPE))
-    }
-
-    #[allow(unused_variables)]
-    fn fchmod(&mut self, id: usize, mode: u16) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fevent(&mut self, id: usize, flags: EventFlags) -> Result<Option<EventFlags>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn frename(&mut self, id: usize, path: &str, uid: u32, gid: u32) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fsync(&mut self, id: usize) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn ftruncate(&mut self, id: usize, len: usize) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn close(&mut self, id: usize) -> Result<Option<usize>> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<Option<usize>> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-
-    #[allow(unused_variables)]
-    fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<Option<usize>> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-}
diff --git a/src/scheme_mut.rs b/src/scheme_mut.rs
deleted file mode 100644
index ebcd30d7d04c2ac3c4c0233ba53503ec07a90267..0000000000000000000000000000000000000000
--- a/src/scheme_mut.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use crate::*;
-use syscall::dirent::DirentBuf;
-use syscall::error::*;
-
-pub trait SchemeMut {
-    #[allow(unused_variables)]
-    fn open(&mut self, path: &str, flags: usize, uid: u32, gid: u32) -> Result<usize> {
-        Err(Error::new(ENOENT))
-    }
-    #[allow(unused_variables)]
-    fn xopen(&mut self, path: &str, flags: usize, ctx: &CallerCtx) -> Result<OpenResult> {
-        convert_to_this_scheme(self.open(path, flags, ctx.uid, ctx.gid))
-    }
-
-    #[allow(unused_variables)]
-    fn rmdir(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
-        Err(Error::new(ENOENT))
-    }
-
-    #[allow(unused_variables)]
-    fn unlink(&mut self, path: &str, uid: u32, gid: u32) -> Result<usize> {
-        Err(Error::new(ENOENT))
-    }
-
-    /* Resource operations */
-    #[allow(unused_variables)]
-    fn dup(&mut self, old_id: usize, buf: &[u8]) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn xdup(&mut self, old_id: usize, buf: &[u8], ctx: &CallerCtx) -> Result<OpenResult> {
-        convert_to_this_scheme(self.dup(old_id, buf))
-    }
-
-    #[allow(unused_variables)]
-    fn read_old(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-    #[allow(unused_variables)]
-    fn read(&mut self, id: usize, buf: &mut [u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
-        self.read_old(id, buf)
-    }
-
-    #[allow(unused_variables)]
-    fn write_old(&mut self, id: usize, buf: &[u8]) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-    #[allow(unused_variables)]
-    fn write(&mut self, id: usize, buf: &[u8], offset: u64, fcntl_flags: u32) -> Result<usize> {
-        self.write_old(id, buf)
-    }
-
-    #[allow(unused_variables)]
-    fn getdents<'buf>(
-        &mut self,
-        id: usize,
-        buf: DirentBuf<&'buf mut [u8]>,
-        opaque_offset: u64,
-    ) -> Result<DirentBuf<&'buf mut [u8]>> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-
-    #[allow(unused_variables)]
-    fn fsize(&mut self, id: usize) -> Result<u64> {
-        Err(Error::new(ESPIPE))
-    }
-
-    #[allow(unused_variables)]
-    fn fchmod(&mut self, id: usize, mode: u16) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fchown(&mut self, id: usize, uid: u32, gid: u32) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fcntl(&mut self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fevent(&mut self, id: usize, flags: EventFlags) -> Result<EventFlags> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fpath(&mut self, id: usize, buf: &mut [u8]) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn frename(&mut self, id: usize, path: &str, uid: u32, gid: u32) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fstat(&mut self, id: usize, stat: &mut Stat) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fstatvfs(&mut self, id: usize, stat: &mut StatVfs) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn fsync(&mut self, id: usize) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn ftruncate(&mut self, id: usize, len: usize) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn futimens(&mut self, id: usize, times: &[TimeSpec]) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn close(&mut self, id: usize) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    #[allow(unused_variables)]
-    fn mmap_prep(&mut self, id: usize, offset: u64, size: usize, flags: MapFlags) -> Result<usize> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-
-    #[allow(unused_variables)]
-    fn munmap(&mut self, id: usize, offset: u64, size: usize, flags: MunmapFlags) -> Result<usize> {
-        Err(Error::new(EOPNOTSUPP))
-    }
-}