Remove the use of RefCell in File

The previous `RefCell` was only dealing with a pointer and the data was always
held by the lfs side so the checking from the refcell was useless anyways

This also contains a breaking change because the `unsafe` `open` function
did not take the correct lifetime.

It think it's an acceptable breaking change because the previous behaviour was buggy
and any code that depends on it likely has a use after free.

Author: sosthene-nitrokey

src/fs.rs

@@ -1,6 +1,7 @@
 //! Experimental Filesystem version using closures.
 
 use core::ffi::{c_int, c_void};
+use core::marker::PhantomData;
 use core::ptr::addr_of;
 use core::ptr::addr_of_mut;
 use core::{
@@ -612,7 +613,8 @@ impl<S: driver::Storage> FileAllocation<S> {
 pub struct File<'a, 'b, S: driver::Storage> {
     // We must store a raw pointer here since the FFI retains a copy of a pointer
     // to the field alloc.state, so we cannot assert unique mutable access.
-    alloc: RefCell<*mut FileAllocation<S>>,
+    alloc: *mut FileAllocation<S>,
+    phantom: PhantomData<&'b mut FileAllocation<S>>,
     fs: &'b Filesystem<'a, S>,
 }
 
@@ -687,7 +689,7 @@ impl<'a, 'b, Storage: driver::Storage> File<'a, 'b, Storage> {
             // We need to use addr_of_mut! here instead of & mut since
             // the FFI stores a copy of a pointer to the field state,
             // so we cannot assert unique mutable access.
-            addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+            addr_of_mut!((*self.alloc).state),
         );
         result_from((), return_code)
     }
@@ -700,7 +702,7 @@ impl<'a, 'b, Storage: driver::Storage> File<'a, 'b, Storage> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_sync(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
             )
         };
         result_from((), return_code)
@@ -714,7 +716,7 @@ impl<'a, 'b, Storage: driver::Storage> File<'a, 'b, Storage> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_size(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
             )
         };
         u32_result(return_code).map(|n| n as usize)
@@ -736,7 +738,7 @@ impl<'a, 'b, Storage: driver::Storage> File<'a, 'b, Storage> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_truncate(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
                 size as u32,
             )
         };
@@ -803,7 +805,7 @@ impl OpenOptions {
     pub unsafe fn open<'a, 'b, S: driver::Storage>(
         &self,
         fs: &'b Filesystem<'a, S>,
-        alloc: &mut FileAllocation<S>,
+        alloc: &'b mut FileAllocation<S>,
         path: &Path,
     ) -> Result<File<'a, 'b, S>> {
         alloc.config.buffer = alloc.cache.get() as *mut _;
@@ -819,7 +821,8 @@ impl OpenOptions {
         );
 
         let file = File {
-            alloc: RefCell::new(alloc),
+            alloc,
+            phantom: PhantomData,
             fs,
         };
 
@@ -919,7 +922,7 @@ impl<S: driver::Storage> io::Read for File<'_, '_, S> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_read(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
                 buf.as_mut_ptr() as *mut c_void,
                 buf.len() as u32,
             )
@@ -936,7 +939,7 @@ impl<S: driver::Storage> io::Seek for File<'_, '_, S> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_seek(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
                 pos.off(),
                 pos.whence(),
             )
@@ -953,7 +956,7 @@ impl<S: driver::Storage> io::Write for File<'_, '_, S> {
             // so we cannot assert unique mutable access.
             ll::lfs_file_write(
                 &mut self.fs.alloc.borrow_mut().state,
-                addr_of_mut!((*(*self.alloc.borrow_mut())).state),
+                addr_of_mut!((*self.alloc).state),
                 buf.as_ptr() as *const c_void,
                 buf.len() as u32,
             )