mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
refactoring to simplify free key index tracking.
This commit is contained in:
parent
193f563782
commit
00339b0c5f
3 changed files with 193 additions and 79 deletions
|
|
@ -276,16 +276,17 @@ impl BasisCache {
|
||||||
}
|
}
|
||||||
let mut init_flags = DictFlags(0);
|
let mut init_flags = DictFlags(0);
|
||||||
init_flags.set_valid(true);
|
init_flags.set_valid(true);
|
||||||
|
let mut free_keys = BinaryHeap::<FreeKeyRange>::new();
|
||||||
|
free_keys.push(FreeKeyRange{start: 1, run: KEY_MAXCOUNT as u32 - 1});
|
||||||
let dict_cache = DictCacheEntry {
|
let dict_cache = DictCacheEntry {
|
||||||
index: dict_index,
|
index: dict_index,
|
||||||
keys: HashMap::<String, KeyCacheEntry>::new(),
|
keys: HashMap::<String, KeyCacheEntry>::new(),
|
||||||
clean: false,
|
clean: false,
|
||||||
age: 0,
|
age: 0,
|
||||||
|
free_keys: RefCell::new(free_keys),
|
||||||
|
last_disk_key_index: KEY_MAXCOUNT as u32,
|
||||||
flags: init_flags,
|
flags: init_flags,
|
||||||
key_count: 0,
|
key_count: 0,
|
||||||
free_key_offset: Some(0),
|
|
||||||
free_key_offset_hint: None,
|
|
||||||
key_max_free_offset: 1,
|
|
||||||
small_pool: Vec::<KeySmallPool>::new(),
|
small_pool: Vec::<KeySmallPool>::new(),
|
||||||
small_pool_free: BinaryHeap::<KeySmallPoolOrd>::new(),
|
small_pool_free: BinaryHeap::<KeySmallPoolOrd>::new(),
|
||||||
aad: my_aad,
|
aad: my_aad,
|
||||||
|
|
@ -838,6 +839,19 @@ impl BasisCacheEntry {
|
||||||
for (key_name, key) in dict.keys.iter_mut() {
|
for (key_name, key) in dict.keys.iter_mut() {
|
||||||
log::info!("merging in key {}", key_name);
|
log::info!("merging in key {}", key_name);
|
||||||
if !key.clean {
|
if !key.clean {
|
||||||
|
// allocate a key index if one hasn't already been allocated
|
||||||
|
if key.descriptor_index.is_none() {
|
||||||
|
if let Some(new_index) = dict.get_free_key_index() {
|
||||||
|
key.descriptor_index = Some(new_index);
|
||||||
|
// if the new index is outside the currently known set, raise the search extent for the brute-force search
|
||||||
|
if new_index.get() > dict.last_disk_key_index {
|
||||||
|
dict.last_disk_key_index = new_index.get();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
log::error!("Dictionary {} ran out of key capacity during sync", name);
|
||||||
|
return Err(Error::new(ErrorKind::OutOfMemory, "Dict ran out of key slots"));
|
||||||
|
}
|
||||||
|
}
|
||||||
if key.descriptor_vaddr(dict_offset) >= cur_vpage &&
|
if key.descriptor_vaddr(dict_offset) >= cur_vpage &&
|
||||||
key.descriptor_vaddr(dict_offset) < next_vpage {
|
key.descriptor_vaddr(dict_offset) < next_vpage {
|
||||||
// key is within the current page, add it to the target list
|
// key is within the current page, add it to the target list
|
||||||
|
|
@ -857,41 +871,12 @@ impl BasisCacheEntry {
|
||||||
for (&src, dst) in key_desc.deref().iter().zip(dk_entry.data.iter_mut()) {
|
for (&src, dst) in key_desc.deref().iter().zip(dk_entry.data.iter_mut()) {
|
||||||
*dst = src;
|
*dst = src;
|
||||||
}
|
}
|
||||||
// ensure that we have a free_key offset with a perhaps slow brute-force search of the key space
|
if let Some(dk_index) = key.descriptor_index {
|
||||||
if dict.free_key_offset.is_none() {
|
dk_vpage.elements[dk_index.get() as usize % DK_PER_VPAGE] = Some(dk_entry);
|
||||||
let mut index_cache = PlaintextCache { data: None, tag: None };
|
} else {
|
||||||
let mut try_entry = dict.free_key_offset_hint.take().unwrap_or(1) as usize;
|
log::error!("Dictionary {} ran out of key capacity during sync", name);
|
||||||
while try_entry < KEY_MAXCOUNT {
|
return Err(Error::new(ErrorKind::OutOfMemory, "Dict ran out of key slots"));
|
||||||
let req_vaddr = dict.index as u64 * DICT_VSIZE + ((try_entry / DK_PER_VPAGE) as u64) * VPAGE_SIZE as u64;
|
|
||||||
index_cache.fill(hw, &self.v2p_map, &self.cipher, &dict.aad, VirtAddr::new(req_vaddr).unwrap());
|
|
||||||
if index_cache.data.is_none() || index_cache.tag.is_none() {
|
|
||||||
dict.free_key_offset = Some(try_entry as u32);
|
|
||||||
log::warn!("Dictionary fill op encountered an unallocated page checking entry {} in the dictionary map. Marking it for re-use.", try_entry);
|
|
||||||
break;
|
|
||||||
} else {
|
|
||||||
let cache = index_cache.data.as_ref().expect("Cache should be full, it was already checked...");
|
|
||||||
let pp = index_cache.tag.as_ref().expect("PP should be in existence, it was already checked...");
|
|
||||||
let mut keydesc = KeyDescriptor::default();
|
|
||||||
let start = size_of::<JournalType>() + (try_entry % DK_PER_VPAGE) * DK_STRIDE;
|
|
||||||
for (&src, dst) in cache[start..start + DK_STRIDE].iter().zip(keydesc.deref_mut().iter_mut()) {
|
|
||||||
*dst = src;
|
|
||||||
}
|
|
||||||
if !keydesc.flags.valid() {
|
|
||||||
dict.free_key_offset = Some(try_entry as u32);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
try_entry += 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
let dk_index = dict.free_key_offset.take().expect("ensure_key_offset() failed");
|
|
||||||
dict.free_key_offset_hint = Some(dk_index + 1);
|
|
||||||
if dk_index + 1 > dict.key_max_free_offset {
|
|
||||||
// only reset the free key offset if it so happened that the free key was the last one: sometimes, the key could be in the middle of the array
|
|
||||||
dict.key_max_free_offset = dk_index + 2; // set the hint one past the end of the pool
|
|
||||||
}
|
|
||||||
dk_vpage.elements[dk_index as usize % DK_PER_VPAGE] = Some(dk_entry);
|
|
||||||
}
|
}
|
||||||
key.clean = true;
|
key.clean = true;
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -14,6 +14,7 @@ use std::iter::IntoIterator;
|
||||||
use std::collections::{HashMap, BinaryHeap};
|
use std::collections::{HashMap, BinaryHeap};
|
||||||
use std::io::{Result, Error, ErrorKind};
|
use std::io::{Result, Error, ErrorKind};
|
||||||
use bitfield::bitfield;
|
use bitfield::bitfield;
|
||||||
|
use std::cmp::Ordering;
|
||||||
|
|
||||||
bitfield! {
|
bitfield! {
|
||||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||||
|
|
@ -22,6 +23,54 @@ bitfield! {
|
||||||
pub valid, set_valid: 0;
|
pub valid, set_valid: 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[derive(PartialEq, Eq)]
|
||||||
|
pub(crate) enum FreeKeyCases {
|
||||||
|
LeftAdjacent,
|
||||||
|
RightAdjacent,
|
||||||
|
Within,
|
||||||
|
LessThan,
|
||||||
|
GreaterThan,
|
||||||
|
}
|
||||||
|
#[derive(Eq, Copy, Clone)]
|
||||||
|
pub(crate) struct FreeKeyRange {
|
||||||
|
/// This index should be free
|
||||||
|
pub(crate) start: u32,
|
||||||
|
/// Additional free keys after the start one. Run = 0 means just the start key is free, and the
|
||||||
|
/// next one should be used. Run = 2 means {start, start+1} are free, etc.
|
||||||
|
pub(crate) run: u32,
|
||||||
|
}
|
||||||
|
impl FreeKeyRange {
|
||||||
|
pub(crate) fn compare_to(&self, index: u32) -> FreeKeyCases {
|
||||||
|
if self.start > 1 && index < self.start - 1 {
|
||||||
|
FreeKeyCases::LessThan
|
||||||
|
} else if self.start > 0 && index == self.start - 1 {
|
||||||
|
FreeKeyCases::LeftAdjacent
|
||||||
|
} else if index >= self.start && index <= self.start + self.run {
|
||||||
|
FreeKeyCases::Within
|
||||||
|
} else if index == self.start + self.run + 1 {
|
||||||
|
FreeKeyCases::RightAdjacent
|
||||||
|
} else {
|
||||||
|
FreeKeyCases::GreaterThan
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Ord for FreeKeyRange {
|
||||||
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
|
// note the reverse order -- so we can sort as a "min-heap"
|
||||||
|
other.start.cmp(&self.start)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl PartialOrd for FreeKeyRange {
|
||||||
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
|
Some(self.cmp(other))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl PartialEq for FreeKeyRange {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.start == other.start
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// stashed copy of a decrypted page. The copy here must always match
|
/// stashed copy of a decrypted page. The copy here must always match
|
||||||
/// what's actually on disk; do not mutate it and expect it to sync with the disk.
|
/// what's actually on disk; do not mutate it and expect it to sync with the disk.
|
||||||
/// Remember to invalidate this if the data are
|
/// Remember to invalidate this if the data are
|
||||||
|
|
@ -71,13 +120,11 @@ pub(crate) struct DictCacheEntry {
|
||||||
pub(crate) keys: HashMap::<String, KeyCacheEntry>,
|
pub(crate) keys: HashMap::<String, KeyCacheEntry>,
|
||||||
/// count of total keys in the dictionary -- may be equal to or larger than the number of elements in `keys`
|
/// count of total keys in the dictionary -- may be equal to or larger than the number of elements in `keys`
|
||||||
pub(crate) key_count: u32,
|
pub(crate) key_count: u32,
|
||||||
/// a cached copy of the next free key slot, expressed in units of DK_STRIDE, with 0 being the first valid key offset
|
/// track the pool of free key indices. Wrapped in a refcell so we can work the index mechanism while updating the keys HashMap
|
||||||
/// when free_key_offset is taken, it's recommended to add 1 to it and store a copy in free_key_offset_hint.
|
pub(crate) free_keys: RefCell<BinaryHeap::<FreeKeyRange>>,
|
||||||
pub(crate) free_key_offset: Option<u32>,
|
/// hint for when to stop doing a brute-force search for the existence of a key in the disk records.
|
||||||
/// optional hint on where to start searching for a free key offset. If None, we start from the beginning.
|
/// This field is set to the max count on a new, naive record; and set only upon a sync() or a fill() call.
|
||||||
pub(crate) free_key_offset_hint: Option<u32>,
|
pub(crate) last_disk_key_index: u32,
|
||||||
/// optimization to terminate key space search if we know there are no more new keys beyond this point
|
|
||||||
pub(crate) key_max_free_offset: u32,
|
|
||||||
/// set if synced to disk. should be cleared if the dict is modified, and/or if a subordinate key descriptor is modified.
|
/// set if synced to disk. should be cleared if the dict is modified, and/or if a subordinate key descriptor is modified.
|
||||||
pub(crate) clean: bool,
|
pub(crate) clean: bool,
|
||||||
/// track modification count
|
/// track modification count
|
||||||
|
|
@ -108,13 +155,14 @@ impl DictCacheEntry {
|
||||||
for &b in aad.iter() {
|
for &b in aad.iter() {
|
||||||
my_aad.push(b);
|
my_aad.push(b);
|
||||||
}
|
}
|
||||||
|
let mut free_keys = BinaryHeap::<FreeKeyRange>::new();
|
||||||
|
free_keys.push(FreeKeyRange{start: 1, run: KEY_MAXCOUNT as u32 - 1});
|
||||||
DictCacheEntry {
|
DictCacheEntry {
|
||||||
index: index as u32,
|
index: index as u32,
|
||||||
keys: HashMap::<String, KeyCacheEntry>::new(),
|
keys: HashMap::<String, KeyCacheEntry>::new(),
|
||||||
key_count: dict.num_keys,
|
key_count: dict.num_keys,
|
||||||
free_key_offset: None,
|
free_keys: RefCell::new(free_keys),
|
||||||
free_key_offset_hint: None,
|
last_disk_key_index: KEY_MAXCOUNT as u32,
|
||||||
key_max_free_offset: KEY_MAXCOUNT as u32, // start with the largest count, adjust down later
|
|
||||||
clean: true,
|
clean: true,
|
||||||
age: dict.age,
|
age: dict.age,
|
||||||
flags: dict.flags,
|
flags: dict.flags,
|
||||||
|
|
@ -144,7 +192,6 @@ impl DictCacheEntry {
|
||||||
|
|
||||||
if index_cache.data.is_none() || index_cache.tag.is_none() {
|
if index_cache.data.is_none() || index_cache.tag.is_none() {
|
||||||
// somehow we hit a page where nothing was allocated (perhaps it was previously deleted?), or less likely, the data was corrupted. Note the isuse, skip past it.
|
// somehow we hit a page where nothing was allocated (perhaps it was previously deleted?), or less likely, the data was corrupted. Note the isuse, skip past it.
|
||||||
if self.free_key_offset.is_none() { self.free_key_offset = Some(try_entry as u32) }
|
|
||||||
log::warn!("Dictionary fill op encountered an unallocated page checking entry {} in the dictionary map. Marking it for re-use.", try_entry);
|
log::warn!("Dictionary fill op encountered an unallocated page checking entry {} in the dictionary map. Marking it for re-use.", try_entry);
|
||||||
try_entry += DK_PER_VPAGE;
|
try_entry += DK_PER_VPAGE;
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -177,15 +224,12 @@ impl DictCacheEntry {
|
||||||
}
|
}
|
||||||
self.keys.insert(kname, kcache);
|
self.keys.insert(kname, kcache);
|
||||||
key_count += 1;
|
key_count += 1;
|
||||||
} else {
|
|
||||||
if self.free_key_offset.is_none() { self.free_key_offset = Some(try_entry as u32) }
|
|
||||||
}
|
}
|
||||||
try_entry += 1;
|
try_entry += 1;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if self.free_key_offset.is_none() { self.free_key_offset = Some(try_entry as u32) }
|
// note where the scan left off, so we don't have to brute-force it in the future
|
||||||
// need to stop one past the empty slot
|
self.last_disk_key_index = try_entry as u32;
|
||||||
self.key_max_free_offset = try_entry as u32 + 1;
|
|
||||||
|
|
||||||
// now build the small_pool_free binary heap structure
|
// now build the small_pool_free binary heap structure
|
||||||
self.rebuild_free_pool();
|
self.rebuild_free_pool();
|
||||||
|
|
@ -207,7 +251,7 @@ impl DictCacheEntry {
|
||||||
let mut try_entry = 1;
|
let mut try_entry = 1;
|
||||||
let mut key_count = 0;
|
let mut key_count = 0;
|
||||||
let mut index_cache = PlaintextCache { data: None, tag: None };
|
let mut index_cache = PlaintextCache { data: None, tag: None };
|
||||||
while try_entry < KEY_MAXCOUNT && key_count < self.key_count && try_entry < self.key_max_free_offset as usize {
|
while try_entry < KEY_MAXCOUNT && key_count < self.key_count && try_entry <= self.last_disk_key_index as usize {
|
||||||
// cache our decryption data -- there's about 32 entries per page, and the scan is largely linear/sequential, so this should
|
// cache our decryption data -- there's about 32 entries per page, and the scan is largely linear/sequential, so this should
|
||||||
// be a substantial savings in effort.
|
// be a substantial savings in effort.
|
||||||
// Determine the absolute virtual address of the requested entry. It's written a little weird because
|
// Determine the absolute virtual address of the requested entry. It's written a little weird because
|
||||||
|
|
@ -217,7 +261,6 @@ impl DictCacheEntry {
|
||||||
|
|
||||||
if index_cache.data.is_none() || index_cache.tag.is_none() {
|
if index_cache.data.is_none() || index_cache.tag.is_none() {
|
||||||
// somehow we hit a page where nothing was allocated (perhaps it was previously deleted?), or less likely, the data was corrupted. Note the isuse, skip past it.
|
// somehow we hit a page where nothing was allocated (perhaps it was previously deleted?), or less likely, the data was corrupted. Note the isuse, skip past it.
|
||||||
if self.free_key_offset.is_none() { self.free_key_offset = Some(try_entry as u32) }
|
|
||||||
log::warn!("Dictionary fill op encountered an unallocated page checking entry {} in the dictionary map. Marking it for re-use.", try_entry);
|
log::warn!("Dictionary fill op encountered an unallocated page checking entry {} in the dictionary map. Marking it for re-use.", try_entry);
|
||||||
try_entry += DK_PER_VPAGE;
|
try_entry += DK_PER_VPAGE;
|
||||||
} else {
|
} else {
|
||||||
|
|
@ -246,8 +289,6 @@ impl DictCacheEntry {
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
key_count += 1;
|
key_count += 1;
|
||||||
} else {
|
|
||||||
if self.free_key_offset.is_none() { self.free_key_offset = Some(try_entry as u32) }
|
|
||||||
}
|
}
|
||||||
try_entry += 1;
|
try_entry += 1;
|
||||||
}
|
}
|
||||||
|
|
@ -359,44 +400,55 @@ impl DictCacheEntry {
|
||||||
unimplemented!("caching is not yet implemented for large data sets");
|
unimplemented!("caching is not yet implemented for large data sets");
|
||||||
} else {
|
} else {
|
||||||
// 1. handle unaligned start offsets
|
// 1. handle unaligned start offsets
|
||||||
let mut cur_offset = offset as u64;
|
let mut written: usize = 0;
|
||||||
if ((kcache.start + cur_offset) % VPAGE_SIZE as u64) != 0 {
|
if ((kcache.start + offset as u64) % VPAGE_SIZE as u64) != 0 {
|
||||||
let start_vpage_addr = ((kcache.start + cur_offset) / VPAGE_SIZE as u64) * VPAGE_SIZE as u64;
|
let start_vpage_addr = ((kcache.start + offset as u64) / VPAGE_SIZE as u64) * VPAGE_SIZE as u64;
|
||||||
let pp = v2p_map.get(&VirtAddr::new(start_vpage_addr).unwrap()).expect("large key data allocation missing");
|
let pp = v2p_map.get(&VirtAddr::new(start_vpage_addr).unwrap()).expect("large key data allocation missing");
|
||||||
let mut pt_data = hw.data_decrypt_page(&cipher, &self.aad, pp).expect("Decryption auth error");
|
let mut pt_data = hw.data_decrypt_page(&cipher, &self.aad, pp).expect("Decryption auth error");
|
||||||
for (&src, dst) in data.iter().zip(pt_data[size_of::<JournalType>() + offset..].iter_mut()) {
|
for (&src, dst) in data[written..].iter().zip(pt_data[size_of::<JournalType>() + offset..].iter_mut()) {
|
||||||
*dst = src;
|
*dst = src;
|
||||||
cur_offset += 1;
|
written += 1;
|
||||||
}
|
}
|
||||||
assert!((kcache.start + cur_offset) % VPAGE_SIZE as u64 == 0, "alignment algorithm failed");
|
assert!((kcache.start + offset as u64 + written as u64) % VPAGE_SIZE as u64 == 0, "alignment algorithm failed");
|
||||||
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut pt_data, &pp);
|
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut pt_data, &pp);
|
||||||
}
|
}
|
||||||
// 2. do the rest
|
// 2. do the rest
|
||||||
while (cur_offset - offset as u64) < data.len() as u64 {
|
while written < data.len() {
|
||||||
// overwrite whole pages without decryption
|
let vpage_addr = ((kcache.start + written as u64 + offset as u64) / VPAGE_SIZE as u64) * VPAGE_SIZE as u64;
|
||||||
let vpage_addr = ((kcache.start + cur_offset) / VPAGE_SIZE as u64) * VPAGE_SIZE as u64;
|
|
||||||
let pp = v2p_map.get(&VirtAddr::new(vpage_addr).unwrap()).expect("large key data allocation missing");
|
let pp = v2p_map.get(&VirtAddr::new(vpage_addr).unwrap()).expect("large key data allocation missing");
|
||||||
if data.len() as u64 - (cur_offset - offset as u64) > VPAGE_SIZE as u64 {
|
if data.len() - written >= VPAGE_SIZE {
|
||||||
|
// overwrite whole pages without decryption
|
||||||
let mut block = [0u8; VPAGE_SIZE + size_of::<JournalType>()];
|
let mut block = [0u8; VPAGE_SIZE + size_of::<JournalType>()];
|
||||||
for (&src, dst) in data.iter().zip(block[size_of::<JournalType>()..].iter_mut()) {
|
for (&src, dst) in data[written..].iter().zip(block[size_of::<JournalType>()..].iter_mut()) {
|
||||||
*dst = src;
|
*dst = src;
|
||||||
cur_offset += 1;
|
written += 1;
|
||||||
}
|
}
|
||||||
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut block, pp);
|
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut block, pp);
|
||||||
} else {
|
} else {
|
||||||
let mut pt_data = hw.data_decrypt_page(&cipher, &self.aad, pp).expect("Decryption auth error");
|
// handle partial trailing pages
|
||||||
for (&src, dst) in data.iter().zip(pt_data[size_of::<JournalType>()..].iter_mut()) {
|
if let Some(pt_data) = hw.data_decrypt_page(&cipher, &self.aad, pp).as_mut() {
|
||||||
*dst = src;
|
for (&src, dst) in data[written..].iter().zip(pt_data[size_of::<JournalType>()..].iter_mut()) {
|
||||||
cur_offset += 1;
|
*dst = src;
|
||||||
|
written += 1;
|
||||||
|
}
|
||||||
|
hw.data_encrypt_and_patch_page(cipher, &self.aad, pt_data, pp);
|
||||||
|
} else {
|
||||||
|
// page didn't exist, initialize it with 0's and merge the tail end.
|
||||||
|
let mut pt_data = [0u8; VPAGE_SIZE + size_of::<JournalType>()];
|
||||||
|
for (&src, dst) in data[written..].iter().zip(pt_data[size_of::<JournalType>()..].iter_mut()) {
|
||||||
|
*dst = src;
|
||||||
|
written += 1;
|
||||||
|
}
|
||||||
|
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut pt_data, pp);
|
||||||
}
|
}
|
||||||
hw.data_encrypt_and_patch_page(cipher, &self.aad, &mut pt_data, pp);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
assert!(cur_offset - offset as u64 == data.len() as u64, "algorithm problem -- didn't write all the data we thought we would");
|
log::info!("data written: {}, data requested to write: {}", written, data.len());
|
||||||
|
assert!(written == data.len(), "algorithm problem -- didn't write all the data we thought we would");
|
||||||
// 3. truncate.
|
// 3. truncate.
|
||||||
if truncate {
|
if truncate {
|
||||||
// discard all whole pages after cur_offset, and reset the reserved field to the smaller size.
|
// discard all whole pages after written+offset, and reset the reserved field to the smaller size.
|
||||||
let vpage_end_offset = PageAlignedVa::from(cur_offset);
|
let vpage_end_offset = PageAlignedVa::from((written + offset) as u64);
|
||||||
if (vpage_end_offset.as_u64() - kcache.start) > kcache.reserved {
|
if (vpage_end_offset.as_u64() - kcache.start) > kcache.reserved {
|
||||||
for vpage in (vpage_end_offset.as_u64()..kcache.start + kcache.reserved).step_by(VPAGE_SIZE) {
|
for vpage in (vpage_end_offset.as_u64()..kcache.start + kcache.reserved).step_by(VPAGE_SIZE) {
|
||||||
if let Some(pp) = v2p_map.remove(&VirtAddr::new(vpage).unwrap()) {
|
if let Some(pp) = v2p_map.remove(&VirtAddr::new(vpage).unwrap()) {
|
||||||
|
|
@ -546,6 +598,13 @@ impl DictCacheEntry {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
// free up the key index in the dictionary
|
||||||
|
if let Some(index) = kcache.descriptor_index {
|
||||||
|
self.put_free_key_index(index.get());
|
||||||
|
} else {
|
||||||
|
// this should be a rare case; later on we can change this warn to a debug, but print something as a bread crumb to future me...
|
||||||
|
log::warn!("Key cache descriptor was none -- should only happen in the case of a key that was removed before it was synchronized to disk");
|
||||||
|
}
|
||||||
if need_rebuild {
|
if need_rebuild {
|
||||||
// no stable "retain" api, so we have to clear the heap and rebuild it https://github.com/rust-lang/rust/issues/71503
|
// no stable "retain" api, so we have to clear the heap and rebuild it https://github.com/rust-lang/rust/issues/71503
|
||||||
self.rebuild_free_pool();
|
self.rebuild_free_pool();
|
||||||
|
|
@ -618,7 +677,6 @@ impl DictCacheEntry {
|
||||||
for key_name in &entry.contents {
|
for key_name in &entry.contents {
|
||||||
let kcache = self.keys.get_mut(key_name).expect("data record without index");
|
let kcache = self.keys.get_mut(key_name).expect("data record without index");
|
||||||
kcache.start = pool_vaddr.get() + pool_offset as u64;
|
kcache.start = pool_vaddr.get() + pool_offset as u64;
|
||||||
kcache.descriptor_index = Some(NonZeroU32::new(index as u32 + 1).unwrap());
|
|
||||||
kcache.age = kcache.age.saturating_add(1);
|
kcache.age = kcache.age.saturating_add(1);
|
||||||
kcache.clean = false;
|
kcache.clean = false;
|
||||||
kcache.flags.set_unresolved(false);
|
kcache.flags.set_unresolved(false);
|
||||||
|
|
@ -642,9 +700,72 @@ impl DictCacheEntry {
|
||||||
// we now have a bunch of dirty kcache entries. You should call `dict_sync` shortly after this to synchronize those entries to disk.
|
// we now have a bunch of dirty kcache entries. You should call `dict_sync` shortly after this to synchronize those entries to disk.
|
||||||
}
|
}
|
||||||
|
|
||||||
/// This call currently does nothing, because we haven't implemented caching for large pool data yet.
|
/// No data cache to flush yet...large pool caches not implemented!
|
||||||
pub(crate) fn sync_large_pool(&self) {
|
pub(crate) fn sync_large_pool(&self) {
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn get_free_key_index(&self) -> Option<NonZeroU32> {
|
||||||
|
if let Some(free_key) = self.free_keys.borrow_mut().pop() {
|
||||||
|
let index = free_key.start;
|
||||||
|
if free_key.run > 0 {
|
||||||
|
self.free_keys.borrow_mut().push(
|
||||||
|
FreeKeyRange {
|
||||||
|
start: index + 1,
|
||||||
|
run: free_key.run - 1,
|
||||||
|
}
|
||||||
|
)
|
||||||
|
}
|
||||||
|
NonZeroU32::new(index as u32)
|
||||||
|
} else {
|
||||||
|
log::warn!("Ran out of dict index space");
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pub(crate) fn put_free_key_index(&self, index: u32) {
|
||||||
|
let free_keys = self.free_keys.replace(BinaryHeap::<FreeKeyRange>::new());
|
||||||
|
let free_key_vec = free_keys.into_sorted_vec();
|
||||||
|
// this is a bit weird because we have three cases:
|
||||||
|
// - the new key is more than 1 away from any element, in which case we insert it as a singleton (start = index, run = 0)
|
||||||
|
// - the new key is adjacent to exactly once element, in which case we put it either on the top or bottom (merge into existing record)
|
||||||
|
// - the new key is adjacent to exactly two elements, in which case we merge the new key and other two elements together, add its length to the new overall run
|
||||||
|
let mut skip = false;
|
||||||
|
for i in 0..free_key_vec.len() {
|
||||||
|
if skip {
|
||||||
|
// this happens when we merged into the /next/ record, and we reduced the total number of items by one
|
||||||
|
skip = false;
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
match free_key_vec[i].compare_to(i as u32) {
|
||||||
|
FreeKeyCases::LessThan => {
|
||||||
|
self.free_keys.borrow_mut().push(FreeKeyRange{start: index as u32, run: 0});
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
FreeKeyCases::LeftAdjacent => {
|
||||||
|
self.free_keys.borrow_mut().push(FreeKeyRange{start: index as u32, run: free_key_vec[i].run + 1});
|
||||||
|
}
|
||||||
|
FreeKeyCases::Within => {
|
||||||
|
log::error!("Double-free error in free_keys()");
|
||||||
|
panic!("Double-free error in free_keys()");
|
||||||
|
}
|
||||||
|
FreeKeyCases::RightAdjacent => {
|
||||||
|
// see if we should merge to the right
|
||||||
|
if i + 1 < free_key_vec.len() {
|
||||||
|
if free_key_vec[i+1].compare_to(i as u32) == FreeKeyCases::LeftAdjacent {
|
||||||
|
self.free_keys.borrow_mut().push(FreeKeyRange{
|
||||||
|
start: free_key_vec[i].start,
|
||||||
|
run: free_key_vec[i].run + free_key_vec[i+1].run + 2
|
||||||
|
});
|
||||||
|
skip = true
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
self.free_keys.borrow_mut().push(FreeKeyRange { start: free_key_vec[i].start, run: free_key_vec[i].run + 1 })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
FreeKeyCases::GreaterThan => {
|
||||||
|
self.free_keys.borrow_mut().push(free_key_vec[i]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
pub(crate) fn small_storage_index_from_key(kcache: &KeyCacheEntry, dict_index: u32) -> Option<usize> {
|
pub(crate) fn small_storage_index_from_key(kcache: &KeyCacheEntry, dict_index: u32) -> Option<usize> {
|
||||||
|
|
|
||||||
|
|
@ -399,6 +399,14 @@ fn xmain() -> ! {
|
||||||
}
|
}
|
||||||
basis_cache.key_update(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", "12345678".as_bytes(), None, None, None, false).expect("couldn't add a key");
|
basis_cache.key_update(&mut pddb_os, "system settings", "wifi/wpa_keys/e4200", "12345678".as_bytes(), None, None, None, false).expect("couldn't add a key");
|
||||||
|
|
||||||
|
/*
|
||||||
|
// add a "big" key
|
||||||
|
let mut bigdata = [0u8; 5000];
|
||||||
|
for (i, d) in bigdata.iter_mut().enumerate() {
|
||||||
|
*d = i as u8;
|
||||||
|
}
|
||||||
|
basis_cache.key_update(&mut pddb_os, "system settings", "big_pool1", &bigdata, None, None, None, false).expect("couldn't add a key");
|
||||||
|
*/
|
||||||
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
#[cfg(not(any(target_os = "none", target_os = "xous")))]
|
||||||
pddb_os.dbg_dump();
|
pddb_os.dbg_dump();
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue