Remove need for generic array and typenum constants

This will also allow for more flexible `Storage` implementations
that use `Vec<u8>` as a cache buffer and are not fixed to a single block size

Author: sosthene-nitrokey

Cargo.toml

@@ -22,9 +22,12 @@ repository.workspace = true
 [package.metadata.docs.rs]
 all-features = true
 
+[[example]]
+name = "list"
+required-features = ["alloc"]
+
 [dependencies]
 delog = "0.1.0"
-generic-array = "0.14"
 heapless = "0.7"
 littlefs2-core = { version = "0.1", path = "core" }
 littlefs2-sys = { version = "0.3.1", features = ["multiversion"] }

examples/list.rs

@@ -30,7 +30,7 @@ fn main() {
         file,
         len: actual_len,
     };
-    let mut alloc = Allocation::new();
+    let mut alloc = Allocation::new(&s);
     let fs = Filesystem::mount(&mut alloc, &mut s).expect("failed to mount filesystem");
 
     let available_blocks = fs.available_blocks().unwrap();
@@ -70,13 +70,21 @@ struct FileStorage {
 }
 
 impl Storage for FileStorage {
-    type CACHE_SIZE = U512;
-    type LOOKAHEAD_SIZE = U1;
+    type CACHE_BUFFER = Vec<u8>;
+    type LOOKAHEAD_BUFFER = Vec<u8>;
 
-    const READ_SIZE: usize = 16;
-    const WRITE_SIZE: usize = 512;
-    const BLOCK_SIZE: usize = BLOCK_SIZE;
-    const BLOCK_COUNT: usize = BLOCK_COUNT;
+    fn read_size(&self) -> usize {
+        16
+    }
+    fn write_size(&self) -> usize {
+        512
+    }
+    fn block_size(&self) -> usize {
+        BLOCK_SIZE
+    }
+    fn block_count(&self) -> usize {
+        BLOCK_COUNT
+    }
 
     fn read(&mut self, off: usize, buf: &mut [u8]) -> Result<usize> {
         assert!(off + buf.len() <= BLOCK_SIZE * BLOCK_COUNT);

src/consts.rs

@@ -1,8 +1,5 @@
 #![allow(non_camel_case_types)]
 
-/// Re-export of `typenum::consts`.
-pub use generic_array::typenum::consts::*;
-
 pub const PATH_MAX: usize = littlefs2_core::PathBuf::MAX_SIZE;
 pub const PATH_MAX_PLUS_ONE: usize = littlefs2_core::PathBuf::MAX_SIZE_PLUS_ONE;
 pub const FILENAME_MAX_PLUS_ONE: u32 = 255 + 1;

src/driver.rs

@@ -1,55 +1,125 @@
 //! The `Storage`, `Read`, `Write` and `Seek` driver.
 #![allow(non_camel_case_types)]
 
-use generic_array::ArrayLength;
-
 use crate::io::Result;
 
+mod private {
+    pub trait Sealed {}
+}
+
+/// Safety: implemented only by `[u8; N]` and `Vec<u8>` if the alloc feature is enabled
+pub unsafe trait Buffer: private::Sealed {
+    /// The maximum capacity of the buffer type.
+    /// Can be [`usize::Max`]()
+    const MAX_CAPACITY: usize;
+
+    /// Returns a buffer of bytes initialized and valid. If [`set_capacity`]() was called previously,
+    /// its last call defines the minimum number of valid bytes
+    fn as_ptr(&self) -> *const u8;
+    /// Returns a buffer of bytes initialized and valid. If [`set_capacity`]() was called previously,
+    /// its last call defines the minimum number of valid bytes
+    fn as_mut_ptr(&mut self) -> *mut u8;
+
+    /// Can panic if `capacity` > `Self::MAX_CAPACITY`
+    fn set_capacity(&mut self, capacity: usize);
+
+    /// Can panic if `capacity` > `Self::MAX_CAPACITY`
+    fn with_capacity(capacity: usize) -> Self;
+}
+
+impl<const N: usize> private::Sealed for [u8; N] {}
+
+unsafe impl<const N: usize> Buffer for [u8; N] {
+    const MAX_CAPACITY: usize = N;
+
+    fn as_ptr(&self) -> *const u8 {
+        <[u8]>::as_ptr(self)
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        <[u8]>::as_mut_ptr(self)
+    }
+
+    fn set_capacity(&mut self, _capacity: usize) {
+        // noop, fixed capacity
+    }
+    fn with_capacity(capacity: usize) -> Self {
+        assert!(capacity <= N);
+        [0; N]
+    }
+}
+
+#[cfg(feature = "alloc")]
+impl private::Sealed for Vec<u8> {}
+
+#[cfg(feature = "alloc")]
+unsafe impl<const N: usize> Buffer for alloc::Vec<u8> {
+    const MAX_CAPACITY: usize = usize::MAX;
+    const DEFAULT: Self;
+
+    fn as_ptr(&self) -> *const u8 {
+        <[u8]>::as_ptr(self)
+    }
+
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        <[u8]>::as_mut_ptr(self)
+    }
+
+    fn set_capacity(&mut self, capacity: usize) {
+        self.resize(capacity, 0)
+    }
+
+    fn with_capacity(capacity: usize) -> Self {
+        let mut this = Vec::with_capacity(capacity);
+        this.set_capacity(capacity);
+        this
+    }
+}
+
 /// Users of this library provide a "storage driver" by implementing this trait.
 ///
 /// The `write` method is assumed to be synchronized to storage immediately.
 /// littlefs provides more flexibility - if required, this could also be exposed.
 /// Do note that due to caches, files still must be synched. And unfortunately,
 /// this can't be automatically done in `drop`, since it needs mut refs to both
 /// filesystem and storage.
-///
-/// The `*_SIZE` types must be `generic_array::typenume::consts` such as `U256`.
-///
-/// Why? Currently, associated constants can not be used (as constants...) to define
-/// arrays. This "will be fixed" as part of const generics.
-/// Once that's done, we can get rid of `generic-array`s, and replace the
-/// `*_SIZE` types with `usize`s.
 pub trait Storage {
     // /// Error type for user-provided read/write/erase methods
     // type Error = usize;
 
     /// Minimum size of block read in bytes. Not in superblock
-    const READ_SIZE: usize;
+    fn read_size(&self) -> usize;
 
     /// Minimum size of block write in bytes. Not in superblock
-    const WRITE_SIZE: usize;
+    fn write_size(&self) -> usize;
 
     /// Size of an erasable block in bytes, as unsigned typenum.
     /// Must be a multiple of both `READ_SIZE` and `WRITE_SIZE`.
     /// [At least 128](https://github.com/littlefs-project/littlefs/issues/264#issuecomment-519963153). Stored in superblock.
-    const BLOCK_SIZE: usize;
+    fn block_size(&self) -> usize;
 
     /// Number of erasable blocks.
     /// Hence storage capacity is `BLOCK_COUNT * BLOCK_SIZE`
-    const BLOCK_COUNT: usize;
+    fn block_count(&self) -> usize;
 
     /// Suggested values are 100-1000, higher is more performant but
     /// less wear-leveled.  Default of -1 disables wear-leveling.
     /// Value zero is invalid, must be positive or -1.
-    const BLOCK_CYCLES: isize = -1;
+    fn block_cycles(&self) -> isize {
+        -1
+    }
 
     /// littlefs uses a read cache, a write cache, and one cache per per file.
-    /// Must be a multiple of `READ_SIZE` and `WRITE_SIZE`.
-    /// Must be a factor of `BLOCK_SIZE`.
-    type CACHE_SIZE: ArrayLength<u8>;
+    type CACHE_BUFFER: Buffer;
+
+    /// Must be a multiple of `read_size` and `write_size`.
+    /// Must be a factor of `block_size`.
+    fn cache_size(&self) -> usize;
 
+    /// Lookahead buffer used by littlefs
+    type LOOKAHEAD_BUFFER: Buffer;
     /// Size of the lookahead buffer used by littlefs, measured in multiples of 8 bytes.
-    type LOOKAHEAD_SIZE: ArrayLength<u64>;
+    fn lookahead_size(&self) -> usize;
 
     ///// Maximum length of a filename plus one. Stored in superblock.
     ///// Should default to 255+1, but associated type defaults don't exist currently.