Flush dir_entry on file close.

Requires mutable access to the volume in order to do the write.

Author: jonathanpallant

examples/create_test.rs

@@ -167,7 +167,7 @@ fn main() {
             let num_written1 = volume_mgr.write(&mut volume, &mut f, &buffer1[..]).unwrap();
             let num_written = volume_mgr.write(&mut volume, &mut f, &buffer[..]).unwrap();
             println!("Number of bytes written: {}\n", num_written + num_written1);
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             let mut f = volume_mgr
                 .open_file_in_dir(
@@ -198,7 +198,7 @@ fn main() {
                 }
             }
             println!("EOF");
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
         }
     }
 }

examples/delete_test.rs

@@ -154,7 +154,7 @@ fn main() {
                 Err(error) => println!("\tCannot delete file: {:?}", error),
             }
             println!("\tClosing {}...", FILE_TO_DELETE);
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             match volume_mgr.delete_file_in_dir(&volume, &root_dir, FILE_TO_DELETE) {
                 Ok(()) => println!("\tDeleted {}.", FILE_TO_DELETE),

examples/readme_test.rs

@@ -109,7 +109,7 @@ fn main() -> Result<(), Error> {
             print!("{}", *b as char);
         }
     }
-    volume_mgr.close_file(&volume0, my_file)?;
+    volume_mgr.close_file(&mut volume0, my_file)?;
     volume_mgr.close_dir(&volume0, root_dir);
     Ok(())
 }

examples/test_mount.rs

@@ -158,7 +158,7 @@ fn main() {
             assert!(volume_mgr
                 .open_file_in_dir(&mut volume, &root_dir, FILE_TO_PRINT, Mode::ReadOnly)
                 .is_err());
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             let test_dir = volume_mgr.open_dir(&volume, &root_dir, "TEST").unwrap();
             // Check we can't open it twice
@@ -187,7 +187,7 @@ fn main() {
                 }
             }
             println!("Checksum over {} bytes: {}", f.length(), csum);
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             assert!(volume_mgr.open_root_dir(&volume).is_err());
             volume_mgr.close_dir(&volume, root_dir);

examples/write_test.rs

@@ -153,7 +153,7 @@ fn main() {
             }
             println!("EOF\n");
             let mut file_size = f.length() as usize;
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             let mut f = volume_mgr
                 .open_file_in_dir(&mut volume, &root_dir, FILE_TO_WRITE, Mode::ReadWriteAppend)
@@ -170,10 +170,7 @@ fn main() {
             for b in &buffer[..] {
                 csum += u32::from(*b);
             }
-            println!(
-                "Number of bytes appendedß: {}\n",
-                num_written + num_written1
-            );
+            println!("Number of bytes appended: {}\n", num_written + num_written1);
             file_size += num_written;
             file_size += num_written1;
 
@@ -190,7 +187,7 @@ fn main() {
                 }
             }
             println!("EOF");
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             println!("\tFinding {}...", FILE_TO_WRITE);
             let dir_ent = volume_mgr
@@ -201,7 +198,12 @@ fn main() {
             let mut f = volume_mgr
                 .open_file_in_dir(&mut volume, &root_dir, FILE_TO_WRITE, Mode::ReadWriteAppend)
                 .unwrap();
-            println!("\nReading from file {}\n", FILE_TO_WRITE);
+            println!(
+                "\nReading from file {}, len {}\n",
+                FILE_TO_WRITE,
+                f.length()
+            );
+            f.seek_from_start(0).unwrap();
             println!("FILE STARTS:");
             let mut csum2 = 0;
             while !f.eof() {
@@ -217,7 +219,7 @@ fn main() {
             }
             println!("EOF\n");
             assert_eq!(f.length() as usize, file_size);
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
 
             assert_eq!(csum, csum2);
 
@@ -254,7 +256,7 @@ fn main() {
                 }
             }
             println!("EOF");
-            volume_mgr.close_file(&volume, f).unwrap();
+            volume_mgr.close_file(&mut volume, f).unwrap();
         }
     }
 }

src/lib.rs

@@ -65,7 +65,7 @@
 //!         print!("{}", *b as char);
 //!     }
 //! }
-//! volume_mgr.close_file(&volume0, my_file)?;
+//! volume_mgr.close_file(&mut volume0, my_file)?;
 //! volume_mgr.close_dir(&volume0, root_dir);
 //! # Ok(())
 //! # }

src/volume_mgr.rs

@@ -658,25 +658,22 @@ where
             file.seek_from_current(to_copy).unwrap();
             file.entry.attributes.set_archive(true);
             file.entry.mtime = self.timesource.get_timestamp();
-            debug!("Updating FAT info sector");
-            match &mut volume.volume_type {
-                VolumeType::Fat(fat) => {
-                    fat.update_info_sector(self)?;
-                    debug!("Updating dir entry");
-                    self.write_entry_to_disk(fat.get_fat_type(), &file.entry)?;
-                }
-            }
+            // Entry update deferred to file close, for performance.
         }
         Ok(written)
     }
 
     /// Close a file with the given full path.
-    pub fn close_file(&mut self, volume: &Volume, file: File) -> Result<(), Error<D::Error>> {
-        // We don't strictly speaking need the volume in order to close a
-        // directory, as we don't flush anything to disk at this point. However,
-        // we take it in case we change this in the future and closing a file
-        // does then cause some disk write to occur.
-        let _ = volume;
+    pub fn close_file(&mut self, volume: &mut Volume, file: File) -> Result<(), Error<D::Error>> {
+        match volume.volume_type {
+            VolumeType::Fat(ref mut fat) => {
+                debug!("Updating FAT info sector");
+                fat.update_info_sector(self)?;
+                debug!("Updating dir entry {:?}", file.entry);
+                let fat_type = fat.get_fat_type();
+                self.write_entry_to_disk(fat_type, &file.entry)?;
+            }
+        };
 
         // Unwrap, because we should never be in a situation where we're attempting to close a file
         // with an ID which doesn't exist in our open files list.