diff --git a/Cargo.lock b/Cargo.lock
index 391cb20c355c2d2a023a7f24119e03ed9ed5a4cc..424b7a783a99d58bda2057d9606589a9828dc374 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -377,7 +377,7 @@ checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
 
 [[package]]
 name = "redoxfs"
-version = "0.5.9"
+version = "0.5.10"
 dependencies = [
  "aes",
  "argon2",
diff --git a/Cargo.toml b/Cargo.toml
index 7cddf2e5d3726077800cd090031ca0f115464b17..382c5bb7936bec58c21fd9ee05a641a77415ae88 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,7 @@
 name = "redoxfs"
 description = "The Redox Filesystem"
 repository = "https://gitlab.redox-os.org/redox-os/redoxfs"
-version = "0.5.9"
+version = "0.5.10"
 license-file = "LICENSE"
 readme = "README.md"
 authors = ["Jeremy Soller <jackpot51@gmail.com>"]
diff --git a/src/mount/fuse.rs b/src/mount/fuse.rs
index ca2d586945344ebed5d087e50e6fd32707477fb9..24494620b4c97aca3ff7efee98f16a919fda0f9c 100644
--- a/src/mount/fuse.rs
+++ b/src/mount/fuse.rs
@@ -12,7 +12,7 @@ use self::fuser::TimeOrNow;
 use crate::mount::fuse::TimeOrNow::Now;
 use crate::mount::fuse::TimeOrNow::SpecificTime;
 
-use crate::{filesystem, Disk, Node, TreeData, TreePtr, BLOCK_SIZE};
+use crate::{filesystem, Disk, Node, Transaction, TreeData, TreePtr, BLOCK_SIZE};
 
 use self::fuser::{
     FileAttr, FileType, Filesystem, ReplyAttr, ReplyCreate, ReplyData, ReplyDirectory, ReplyEmpty,
@@ -25,7 +25,7 @@ const TTL: Duration = Duration::new(1, 0); // 1 second
 const NULL_TIME: Duration = Duration::new(0, 0);
 
 pub fn mount<D, P, T, F>(
-    filesystem: filesystem::FileSystem<D>,
+    mut filesystem: filesystem::FileSystem<D>,
     mountpoint: P,
     mut callback: F,
 ) -> io::Result<T>
@@ -42,25 +42,32 @@ where
     // be `root`, thus that we need to allow `root` to have access.
     let defer_permissions = [MountOption::CUSTOM("defer_permissions".to_owned())];
 
-    let mut session = Session::new(
-        Fuse { fs: filesystem },
-        mountpoint,
-        if cfg!(target_os = "macos") {
-            &defer_permissions
-        } else {
-            &[]
-        },
-    )?;
+    let res = {
+        let mut session = Session::new(
+            Fuse { fs: &mut filesystem },
+            mountpoint,
+            if cfg!(target_os = "macos") {
+                &defer_permissions
+            } else {
+                &[]
+            },
+        )?;
+
+        let res = callback(mountpoint);
+
+        session.run()?;
 
-    let res = callback(mountpoint);
+        res
+    };
 
-    session.run()?;
+    // Squash allocations and sync on unmount
+    let _ = Transaction::new(&mut filesystem).commit(true);
 
     Ok(res)
 }
 
-pub struct Fuse<D: Disk> {
-    pub fs: filesystem::FileSystem<D>,
+pub struct Fuse<'f, D: Disk> {
+    pub fs: &'f mut filesystem::FileSystem<D>,
 }
 
 fn node_attr(node: &TreeData<Node>) -> FileAttr {
@@ -90,7 +97,7 @@ fn node_attr(node: &TreeData<Node>) -> FileAttr {
     }
 }
 
-impl<D: Disk> Filesystem for Fuse<D> {
+impl<'f, D: Disk> Filesystem for Fuse<'f, D> {
     fn lookup(&mut self, _req: &Request, parent_id: u64, name: &OsStr, reply: ReplyEntry) {
         let parent_ptr = TreePtr::new(parent_id as u32);
         match self
diff --git a/src/mount/redox/mod.rs b/src/mount/redox/mod.rs
index b5b2b739a7f0d80fb8a8f06798ad1078b20ad72f..58b15e0d57eb21433ce17f88f7df29f843bc1bff 100644
--- a/src/mount/redox/mod.rs
+++ b/src/mount/redox/mod.rs
@@ -4,7 +4,7 @@ use std::path::Path;
 use std::sync::atomic::Ordering;
 use syscall::{Packet, SchemeMut};
 
-use crate::{Disk, FileSystem, IS_UMT};
+use crate::{Disk, FileSystem, Transaction, IS_UMT};
 
 use self::scheme::FileScheme;
 
@@ -25,31 +25,27 @@ where
     let res = callback(Path::new(&mounted_path));
 
     let mut scheme = FileScheme::new(format!("{}", mountpoint.display()), filesystem);
-    loop {
-        if IS_UMT.load(Ordering::SeqCst) > 0 {
-            break Ok(res);
-        }
-
+    while IS_UMT.load(Ordering::SeqCst) == 0 {
         let mut packet = Packet::default();
         match socket.read(&mut packet) {
-            Ok(0) => break Ok(res),
+            Ok(0) => break,
             Ok(_ok) => (),
             Err(err) => {
                 if err.kind() == io::ErrorKind::Interrupted {
                     continue;
                 } else {
-                    break Err(err);
+                    return Err(err);
                 }
             }
         }
 
         scheme.handle(&mut packet);
 
-        match socket.write(&packet) {
-            Ok(_ok) => (),
-            Err(err) => {
-                break Err(err);
-            }
-        }
+        socket.write(&packet)?;
     }
+
+    // Squash allocations and sync on unmount
+    let _ = Transaction::new(&mut scheme.fs).commit(true);
+
+    Ok(res)
 }
diff --git a/src/mount/redox/scheme.rs b/src/mount/redox/scheme.rs
index 67c7bac6ab286d61c0aa53aa323edd483c623d72..0e53709b94a6eeb9dfb08b34a36f0a710b3f9605 100644
--- a/src/mount/redox/scheme.rs
+++ b/src/mount/redox/scheme.rs
@@ -21,7 +21,7 @@ use super::resource::{DirResource, FileResource, Resource};
 
 pub struct FileScheme<D: Disk> {
     name: String,
-    fs: FileSystem<D>,
+    pub(crate) fs: FileSystem<D>,
     next_id: AtomicUsize,
     files: BTreeMap<usize, Box<dyn Resource<D>>>,
     fmap: super::resource::Fmaps,