kmwebnet/OpenSK
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Allow read_slice to return a Vec

Browse Source
This commit is contained in:
Julien Cretin
2022-06-03 11:16:43 +02:00
parent 85fe9cd29d
commit f57126634b
5 changed files with 29 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
libraries/persistent_store/src/buffer.rs
View File

@@ -18,7 +18,7 @@
//! actual flash storage. Instead it uses a buffer in memory to represent the storage state.
use crate::{Storage, StorageError, StorageIndex, StorageResult};
use alloc::borrow::Borrow;
use alloc::borrow::{Borrow, Cow};
use alloc::boxed::Box;
use alloc::vec;
@@ -301,8 +301,8 @@ impl Storage for BufferStorage {
self.options.max_page_erases
}
fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<&[u8]> {
Ok(&self.storage[index.range(length, self)?])
fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<Cow<[u8]>> {
Ok(Cow::Borrowed(&self.storage[index.range(length, self)?]))
}
fn write_slice(&mut self, index: StorageIndex, value: &[u8]) -> StorageResult<()> {

4
libraries/persistent_store/src/storage.rs
View File

@@ -14,6 +14,8 @@
//! Flash storage abstraction.
use alloc::borrow::Cow;
/// Represents a byte position in a storage.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct StorageIndex {
@@ -60,7 +62,7 @@ pub trait Storage {
/// Reads a byte slice from the storage.
///
/// The `index` must designate `length` bytes in the storage.
fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<&[u8]>;
fn read_slice(&self, index: StorageIndex, length: usize) -> StorageResult<Cow<[u8]>>;
/// Writes a word slice to the storage.
///

32
libraries/persistent_store/src/store.rs
View File

@@ -25,6 +25,7 @@ use crate::{usize_to_nat, Nat, Storage, StorageError, StorageIndex};
pub use crate::{
BufferStorage, StoreDriver, StoreDriverOff, StoreDriverOn, StoreInterruption, StoreInvariant,
};
use alloc::borrow::Cow;
use alloc::boxed::Box;
use alloc::vec::Vec;
use core::borrow::Borrow;
@@ -490,7 +491,8 @@ impl<S: Storage> Store<S> {
fn recover_initialize(&mut self) -> StoreResult<()> {
let word_size = self.format.word_size();
for page in 0..self.format.num_pages() {
let (init, rest) = self.read_page(page).split_at(word_size as usize);
let content = self.read_page(page);
let (init, rest) = content.split_at(word_size as usize);
if (page > 0 && !is_erased(init)) || !is_erased(rest) {
return Ok(());
}
@@ -890,7 +892,7 @@ impl<S: Storage> Store<S> {
/// Sets the padding bit of a user header.
fn set_padding(&mut self, pos: Position) -> StoreResult<()> {
let mut word = Word::from_slice(self.read_word(pos));
let mut word = Word::from_slice(&self.read_word(pos));
self.format.set_padding(&mut word)?;
self.write_slice(pos, &word.as_slice())?;
Ok(())
@@ -898,7 +900,7 @@ impl<S: Storage> Store<S> {
/// Sets the deleted bit of a user header.
fn set_deleted(&mut self, pos: Position) -> StoreResult<()> {
let mut word = Word::from_slice(self.read_word(pos));
let mut word = Word::from_slice(&self.read_word(pos));
self.format.set_deleted(&mut word);
self.write_slice(pos, &word.as_slice())?;
Ok(())
@@ -1001,13 +1003,13 @@ impl<S: Storage> Store<S> {
0 => None,
_ => Some(self.read_word(*pos + length)),
};
if header.check(footer) {
if header.check(footer.as_deref()) {
if header.key > self.format.max_key() {
return Err(StoreError::InvalidStorage);
}
*pos += 1 + length;
ParsedEntry::User(header)
} else if footer.map_or(true, |x| is_erased(x)) {
} else if footer.map_or(true, |x| is_erased(&x)) {
self.parse_partial(pos)
} else {
*pos += 1 + length;
@@ -1028,7 +1030,7 @@ impl<S: Storage> Store<S> {
fn parse_partial(&self, pos: &mut Position) -> ParsedEntry {
let mut length = None;
for i in 0..self.format.max_prefix_len() {
if !is_erased(self.read_word(*pos + i)) {
if !is_erased(&self.read_word(*pos + i)) {
length = Some(i);
}
}
@@ -1045,20 +1047,20 @@ impl<S: Storage> Store<S> {
fn parse_init(&self, page: Nat) -> StoreResult<WordState<InitInfo>> {
let index = self.format.index_init(page);
let word = self.storage_read_slice(index, self.format.word_size());
self.format.parse_init(Word::from_slice(word))
self.format.parse_init(Word::from_slice(&word))
}
/// Parses the compact info of a page.
fn parse_compact(&self, page: Nat) -> StoreResult<WordState<CompactInfo>> {
let index = self.format.index_compact(page);
let word = self.storage_read_slice(index, self.format.word_size());
self.format.parse_compact(Word::from_slice(word))
self.format.parse_compact(Word::from_slice(&word))
}
/// Parses a word from the virtual storage.
fn parse_word(&self, pos: Position) -> StoreResult<WordState<ParsedWord>> {
self.format
.parse_word(Word::from_slice(self.read_word(pos)))
.parse_word(Word::from_slice(&self.read_word(pos)))
}
/// Reads a slice from the virtual storage.
@@ -1068,22 +1070,22 @@ impl<S: Storage> Store<S> {
let mut result = Vec::with_capacity(length as usize);
let index = pos.index(&self.format);
let max_length = self.format.page_size() - usize_to_nat(index.byte);
result.extend_from_slice(self.storage_read_slice(index, min(length, max_length)));
result.extend_from_slice(&self.storage_read_slice(index, min(length, max_length)));
if length > max_length {
// The slice spans the next page.
let index = pos.next_page(&self.format).index(&self.format);
result.extend_from_slice(self.storage_read_slice(index, length - max_length));
result.extend_from_slice(&self.storage_read_slice(index, length - max_length));
}
result
}
/// Reads a word from the virtual storage.
fn read_word(&self, pos: Position) -> &[u8] {
fn read_word(&self, pos: Position) -> Cow<[u8]> {
self.storage_read_slice(pos.index(&self.format), self.format.word_size())
}
/// Reads a physical page.
fn read_page(&self, page: Nat) -> &[u8] {
fn read_page(&self, page: Nat) -> Cow<[u8]> {
let index = StorageIndex {
page: page as usize,
byte: 0,
@@ -1092,7 +1094,7 @@ impl<S: Storage> Store<S> {
}
/// Reads a slice from the physical storage.
fn storage_read_slice(&self, index: StorageIndex, length: Nat) -> &[u8] {
fn storage_read_slice(&self, index: StorageIndex, length: Nat) -> Cow<[u8]> {
// The only possible failures are if the slice spans multiple pages.
self.storage.read_slice(index, length as usize).unwrap()
}
@@ -1142,7 +1144,7 @@ impl<S: Storage> Store<S> {
/// Erases a page if not already erased.
fn storage_erase_page(&mut self, page: Nat) -> StoreResult<()> {
if !is_erased(self.read_page(page)) {
if !is_erased(&self.read_page(page)) {
self.storage.erase_page(page as usize)?;
}
Ok(())