fix FSCB generation issues

- fix problem where we were generating a size based off of total disk
size, instead of fraction of available space

- enumerate FSCB entries into the page table scan. This is because
the page table cache could hold used entries that aren't reflected
in the low-level disk scan, and there is no way to trigger a
flush at the point of re-allocation.
This commit is contained in:
bunnie 2022-07-04 17:56:54 +08:00
parent 608817f343
commit 8565c7efe1

View file

@ -694,8 +694,8 @@ impl PddbOs {
let ct_to_flash = ciphertext.deref(); let ct_to_flash = ciphertext.deref();
// determine which page we're going to write the ciphertext into // determine which page we're going to write the ciphertext into
let page_search_limit = FSCB_PAGES - ((PageAlignedPa::from(ciphertext.len()).as_usize() / PAGE_SIZE) - 1); let page_search_limit = FSCB_PAGES - ((PageAlignedPa::from(ciphertext.len()).as_usize() / PAGE_SIZE) - 1);
log::info!("picking a random page out of {} pages for fscb", page_search_limit);
let dest_page = self.entropy.borrow_mut().get_u32() % page_search_limit as u32; let dest_page = self.entropy.borrow_mut().get_u32() % page_search_limit as u32;
log::info!("picking random page {} out of {} pages for fscb", dest_page, page_search_limit);
// atomicity of the FreeSpace structure is a bit of a tough topic. It's a fairly hefty structure, // atomicity of the FreeSpace structure is a bit of a tough topic. It's a fairly hefty structure,
// that runs a risk of corruption as it's being written, if power is lost or the system crashes. // that runs a risk of corruption as it's being written, if power is lost or the system crashes.
// However, the guiding principle of this ordering is that it's better to have no FastSpace structure // However, the guiding principle of this ordering is that it's better to have no FastSpace structure
@ -736,8 +736,9 @@ impl PddbOs {
// 1. check that the page_heap has enough entries // 1. check that the page_heap has enough entries
let total_used_pages = page_heap.len(); let total_used_pages = page_heap.len();
let total_free_pages = (PDDB_A_LEN - self.data_phys_base.as_usize()) / PAGE_SIZE; let total_pages = (PDDB_A_LEN - self.data_phys_base.as_usize()) / PAGE_SIZE;
log::info!("page alloc: {} used; {} free", total_used_pages, total_free_pages); let total_free_pages = total_pages - total_used_pages;
log::info!("page alloc: {} used; {} free; {} total", total_used_pages, total_free_pages, total_pages);
if total_free_pages == 0 { if total_free_pages == 0 {
log::warn!("Disk is out of space, no free pages available!"); log::warn!("Disk is out of space, no free pages available!");
// return an empty free_pool vector. // return an empty free_pool vector.
@ -753,7 +754,7 @@ impl PddbOs {
// if the page is used, skip it. // if the page is used, skip it.
if let Some(Reverse(mp)) = min_used_page { if let Some(Reverse(mp)) = min_used_page {
if page_candidate == mp as usize { if page_candidate == mp as usize {
log::info!("removing used page from free_pool: {}", mp); log::debug!("removing used page from free_pool: {}", mp);
min_used_page = page_heap.pop(); min_used_page = page_heap.pop();
continue; continue;
} }
@ -1767,11 +1768,15 @@ impl PddbOs {
pub(crate) fn pddb_generate_used_map(&self, cache: &Vec::<BasisCacheEntry>) -> Option<BinaryHeap<Reverse<u32>>> { pub(crate) fn pddb_generate_used_map(&self, cache: &Vec::<BasisCacheEntry>) -> Option<BinaryHeap<Reverse<u32>>> {
if let Some(all_keys) = self.pddb_get_all_keys(&cache) { if let Some(all_keys) = self.pddb_get_all_keys(&cache) {
let mut page_heap = BinaryHeap::new(); let mut page_heap = BinaryHeap::new();
let mut page_check = HashSet::new(); // this is just for sanity checking because you can't query a heap
for (basis_keys, name) in all_keys { for (basis_keys, name) in all_keys {
// scan the disclosed bases // scan the disclosed bases
if let Some(map) = self.pt_scan_key(&basis_keys.pt, &basis_keys.data, &name) { if let Some(map) = self.pt_scan_key(&basis_keys.pt, &basis_keys.data, &name) {
for pp in map.values() { for pp in map.values() {
page_heap.push(Reverse(pp.page_number())) page_heap.push(Reverse(pp.page_number()));
if !page_check.insert(pp.page_number()) {
log::warn!("double-insert detected of page number {}", pp.page_number());
}
} }
} else { } else {
log::warn!("pt_scan for basis {} failed, data may be lost", name); log::warn!("pt_scan for basis {} failed, data may be lost", name);
@ -1784,8 +1789,16 @@ impl PddbOs {
// the case that any cached allocations came out of the previous FSCB pool, therefore, by merging // the case that any cached allocations came out of the previous FSCB pool, therefore, by merging
// in the "used list" from the existing FSCB we should be able to generate an accurate // in the "used list" from the existing FSCB we should be able to generate an accurate
// representation of the actually used pages // representation of the actually used pages
for pp in self.fspace_cache.iter() {
if pp.space_state() == SpaceState::Used || pp.space_state() == SpaceState::MaybeUsed {
if !page_check.insert(pp.page_number()) {
log::info!("FSCB and page table both record this used page: {} (this is normal)", pp.page_number());
} else {
page_heap.push(Reverse(pp.page_number()));
log::info!("FSCB contained {}, but not yet committed to disk; added to page_heap", pp.page_number());
}
}
}
Some(page_heap) Some(page_heap)
} else { } else {