feat(runtime): implement shared transactional memcard with async saves
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
This commit is contained in:
@@ -0,0 +1,610 @@
|
||||
//! Worker-owned transaction engine. Main-lane callers exchange owned requests/results.
|
||||
use super::image::*;
|
||||
use prometeu_hal::memcard::MemcardStorage;
|
||||
use std::sync::atomic::{AtomicU8, Ordering};
|
||||
|
||||
/// Publication entry and pre-publication cancellation share a single linearization point.
|
||||
#[derive(Default)]
|
||||
pub struct PublicationControl(AtomicU8);
|
||||
impl PublicationControl {
|
||||
pub fn cancel(&self) {
|
||||
self.0.fetch_or(2, Ordering::SeqCst);
|
||||
}
|
||||
pub fn canceled(&self) -> bool {
|
||||
self.0.load(Ordering::SeqCst) & 2 != 0
|
||||
}
|
||||
pub fn publication_attempted(&self) -> bool {
|
||||
self.0.load(Ordering::SeqCst) & 1 != 0
|
||||
}
|
||||
fn enter(&self) -> Result<()> {
|
||||
self.0
|
||||
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |state| {
|
||||
if state & 2 == 0 { Some(state | 1) } else { None }
|
||||
})
|
||||
.map(|_| ())
|
||||
.map_err(|_| Error::Canceled)
|
||||
}
|
||||
fn check(&self) -> Result<()> {
|
||||
if self.canceled() { Err(Error::Canceled) } else { Ok(()) }
|
||||
}
|
||||
}
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum DurableResult {
|
||||
Success,
|
||||
Failure,
|
||||
Indeterminate,
|
||||
}
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct CommitResult {
|
||||
pub durable: DurableResult,
|
||||
pub error: Option<Error>,
|
||||
pub sequence: u64,
|
||||
}
|
||||
|
||||
pub struct Card {
|
||||
io: Box<dyn MemcardStorage>,
|
||||
pub maps: [Option<Map>; 2],
|
||||
pub active: usize,
|
||||
pub catalog: Catalog,
|
||||
scratch: Box<[u8; SLOT_BYTES]>,
|
||||
pub recovered: bool,
|
||||
pub degraded: bool,
|
||||
pub uncertain: bool,
|
||||
pub(super) attempted_publication: Option<Map>,
|
||||
pub write_blocked: bool,
|
||||
known_quarantine: [bool; BLOCK_COUNT],
|
||||
}
|
||||
impl Card {
|
||||
pub fn format(io: &mut dyn MemcardStorage, id: [u8; 16]) -> Result<()> {
|
||||
if io.len()? != IMAGE_BYTES {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
let identity = identity_page(id);
|
||||
io.write_at(0, &identity)?;
|
||||
io.write_at(PAGE_BYTES as u64, &identity)?;
|
||||
let catalog = Catalog::default().encode(0)?;
|
||||
write_region(io, CATALOG_OFFSETS[0], &catalog)?;
|
||||
let mut map = Map::new(id);
|
||||
map.catalog_len = catalog.len() as u32;
|
||||
map.catalog_crc = crc32c(&catalog);
|
||||
let encoded = map.encode()?;
|
||||
io.write_at(MAP_OFFSETS[0], &encoded)?;
|
||||
io.write_at(MAP_OFFSETS[1], &encoded)?;
|
||||
io.sync()?;
|
||||
Ok(())
|
||||
}
|
||||
pub fn mount(mut io: Box<dyn MemcardStorage>) -> Result<Self> {
|
||||
if io.len()? != IMAGE_BYTES {
|
||||
return Err(Error::Unsupported);
|
||||
}
|
||||
let mut page = [0; PAGE_BYTES];
|
||||
let mut identities = [None; 2];
|
||||
let mut recognized = false;
|
||||
for (i, item) in identities.iter_mut().enumerate() {
|
||||
io.read_at((i * PAGE_BYTES) as u64, &mut page)?;
|
||||
recognized |= &page[..8] == b"PMCARD1\0"
|
||||
&& u32::from_le_bytes(page[8..12].try_into().unwrap()) == 1;
|
||||
*item = decode_identity(&page).ok();
|
||||
}
|
||||
let id = identities[0].or(identities[1]).ok_or(if recognized {
|
||||
Error::Corrupt
|
||||
} else {
|
||||
Error::Unsupported
|
||||
})?;
|
||||
if identities.iter().flatten().any(|other| *other != id) {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
let mut maps: [Option<Map>; 2] = [None, None];
|
||||
let mut unknown_metadata = false;
|
||||
for i in 0..2 {
|
||||
io.read_at(MAP_OFFSETS[i], &mut page)?;
|
||||
maps[i] = Map::decode(&page, id).ok();
|
||||
// A zero page is a verified retirement. An undecodable nonzero page
|
||||
// may have lost quarantine information; do not silently reuse its pool.
|
||||
unknown_metadata |= maps[i].is_none() && page.iter().any(|&byte| byte != 0);
|
||||
}
|
||||
if let (Some(a), Some(b)) = (&maps[0], &maps[1])
|
||||
&& a.sequence == b.sequence
|
||||
&& a != b
|
||||
{
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
let highest = maps.iter().flatten().map(|m| m.sequence).max().unwrap_or(0);
|
||||
let mut known = [false; BLOCK_COUNT];
|
||||
for m in maps.iter().flatten() {
|
||||
for (i, &bad) in m.quarantine.iter().enumerate() {
|
||||
known[i] |= bad;
|
||||
}
|
||||
}
|
||||
let mut scratch = Box::new([0; SLOT_BYTES]);
|
||||
let mut catalogs: [Option<Catalog>; 2] = [None, None];
|
||||
let mut lost_map = false;
|
||||
for i in 0..2 {
|
||||
if let Some(m) = &maps[i] {
|
||||
match Self::validate_map(io.as_mut(), m, scratch.as_mut()) {
|
||||
Ok(c) => catalogs[i] = Some(c),
|
||||
Err(Error::Corrupt) => {
|
||||
maps[i] = None;
|
||||
lost_map = true
|
||||
}
|
||||
Err(e) => return Err(e),
|
||||
}
|
||||
}
|
||||
}
|
||||
let active = match (&maps[0], &maps[1]) {
|
||||
(Some(a), Some(b)) => usize::from(b.sequence > a.sequence),
|
||||
(Some(_), None) => 0,
|
||||
(None, Some(_)) => 1,
|
||||
_ => return Err(Error::Corrupt),
|
||||
};
|
||||
let m = maps[active].as_ref().unwrap();
|
||||
let recovered = m.sequence < highest || lost_map || unknown_metadata;
|
||||
let write_blocked =
|
||||
unknown_metadata || known.iter().zip(m.quarantine.iter()).any(|(&a, &b)| a && !b);
|
||||
let degraded = identities.iter().any(Option::is_none)
|
||||
|| maps.iter().any(Option::is_none)
|
||||
|| known.iter().any(|v| *v);
|
||||
Ok(Self {
|
||||
io,
|
||||
maps,
|
||||
active,
|
||||
catalog: catalogs[active].take().unwrap(),
|
||||
scratch,
|
||||
recovered,
|
||||
degraded,
|
||||
uncertain: false,
|
||||
attempted_publication: None,
|
||||
write_blocked,
|
||||
known_quarantine: known,
|
||||
})
|
||||
}
|
||||
fn validate_map(
|
||||
io: &mut dyn MemcardStorage,
|
||||
m: &Map,
|
||||
scratch: &mut [u8; SLOT_BYTES],
|
||||
) -> Result<Catalog> {
|
||||
let mut raw = vec![0; m.catalog_len as usize];
|
||||
read_region(io, CATALOG_OFFSETS[m.public_copy], &mut raw)?;
|
||||
if crc32c(&raw) != m.catalog_crc {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
let catalog = Catalog::decode(&raw, m.icons_len as usize)?;
|
||||
let assigned = catalog.validate(m.icons_len as usize)?;
|
||||
for (s, &expected) in m.slots.iter().zip(&assigned) {
|
||||
if s.assigned != expected {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
if let Some(id) = s.block {
|
||||
io.read_at(block_offset(id)?, &mut scratch[..s.used as usize])?;
|
||||
if crc32c(&scratch[..s.used as usize]) != s.crc {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut crc = !0;
|
||||
let mut at = 0usize;
|
||||
while at < m.icons_len as usize {
|
||||
let n = (m.icons_len as usize - at).min(SLOT_BYTES);
|
||||
io.read_at(ICON_OFFSETS[m.public_copy] + at as u64, &mut scratch[..n])?;
|
||||
crc = crc_extend(crc, &scratch[..n]);
|
||||
at += n;
|
||||
}
|
||||
if crc ^ !0 != m.icons_crc {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
for game in &catalog.games {
|
||||
let n = game.icon.length()?;
|
||||
io.read_at(ICON_OFFSETS[m.public_copy] + game.icon.offset as u64, &mut scratch[..n])?;
|
||||
if crc32c(&scratch[..n]) != game.icon.crc32c {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
}
|
||||
Ok(catalog)
|
||||
}
|
||||
pub fn current(&self) -> &Map {
|
||||
self.maps[self.active].as_ref().unwrap()
|
||||
}
|
||||
pub(super) fn known_exclusions(&self) -> [bool; BLOCK_COUNT] {
|
||||
self.known_quarantine
|
||||
}
|
||||
pub(super) fn remember_exclusions(&mut self, known: [bool; BLOCK_COUNT]) {
|
||||
for (i, bad) in known.into_iter().enumerate() {
|
||||
self.known_quarantine[i] |= bad;
|
||||
self.write_blocked |= bad && !self.current().quarantine[i];
|
||||
}
|
||||
self.degraded |= self.known_quarantine.iter().any(|&bad| bad);
|
||||
}
|
||||
pub fn storage_read_only(&self) -> bool {
|
||||
self.io.read_only()
|
||||
}
|
||||
pub fn into_storage(self) -> Box<dyn MemcardStorage> {
|
||||
self.io
|
||||
}
|
||||
pub fn read_slot(&mut self, slot: usize, target: &mut [u8]) -> Result<usize> {
|
||||
let s = *self.current().slots.get(slot).ok_or(Error::InvalidRange)?;
|
||||
if !s.assigned || target.len() < s.used as usize {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
if let Some(id) = s.block {
|
||||
self.io.read_at(block_offset(id)?, &mut target[..s.used as usize])?;
|
||||
if crc32c(&target[..s.used as usize]) != s.crc {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
}
|
||||
Ok(s.used as usize)
|
||||
}
|
||||
fn writable(&self) -> Result<()> {
|
||||
if self.uncertain {
|
||||
return Err(Error::Indeterminate);
|
||||
}
|
||||
if self.write_blocked || self.io.read_only() {
|
||||
return Err(Error::ReadOnly);
|
||||
}
|
||||
if self.current().sequence == u64::MAX {
|
||||
return Err(Error::CounterExhausted);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
fn retire_inactive(&mut self, control: &PublicationControl) -> Result<()> {
|
||||
control.check()?;
|
||||
let inactive = 1 - self.active;
|
||||
// Also invalidate torn/unknown pages before a previously referenced region is reused.
|
||||
self.io.write_at(MAP_OFFSETS[inactive], &[0; PAGE_BYTES])?;
|
||||
self.io.sync()?;
|
||||
self.io.read_at(MAP_OFFSETS[inactive], &mut self.scratch[..PAGE_BYTES])?;
|
||||
if self.scratch[..PAGE_BYTES].iter().any(|&v| v != 0) {
|
||||
self.write_blocked = true;
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
self.maps[inactive] = None;
|
||||
control.check()
|
||||
}
|
||||
fn publish(&mut self, next: Map, control: &PublicationControl) -> Result<()> {
|
||||
let b = next.encode()?;
|
||||
control.enter()?;
|
||||
self.uncertain = true;
|
||||
self.attempted_publication = Some(next.clone());
|
||||
let inactive = 1 - self.active;
|
||||
self.io.write_at(MAP_OFFSETS[inactive], &b)?;
|
||||
self.io.sync()?;
|
||||
self.io.read_at(MAP_OFFSETS[inactive], &mut self.scratch[..PAGE_BYTES])?;
|
||||
if self.scratch[..PAGE_BYTES] != b {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
self.maps[inactive] = Some(next);
|
||||
self.active = inactive;
|
||||
self.uncertain = false;
|
||||
Ok(())
|
||||
}
|
||||
pub fn commit(
|
||||
&mut self,
|
||||
slot: usize,
|
||||
payload: &[u8],
|
||||
timestamp: u64,
|
||||
control: &PublicationControl,
|
||||
) -> CommitResult {
|
||||
let outcome = self.commit_inner(slot, payload, timestamp, control);
|
||||
CommitResult {
|
||||
durable: if outcome.is_ok() {
|
||||
DurableResult::Success
|
||||
} else if self.uncertain {
|
||||
DurableResult::Indeterminate
|
||||
} else {
|
||||
DurableResult::Failure
|
||||
},
|
||||
error: outcome.err(),
|
||||
sequence: self.current().sequence,
|
||||
}
|
||||
}
|
||||
fn commit_inner(
|
||||
&mut self,
|
||||
slot: usize,
|
||||
payload: &[u8],
|
||||
timestamp: u64,
|
||||
control: &PublicationControl,
|
||||
) -> Result<()> {
|
||||
self.writable()?;
|
||||
self.attempted_publication = None;
|
||||
control.check()?;
|
||||
let old =
|
||||
*self.current().slots.get(slot).filter(|s| s.assigned).ok_or(Error::InvalidRange)?;
|
||||
if payload.len() > SLOT_BYTES {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
let generation = old.generation.checked_add(1).ok_or(Error::CounterExhausted)?;
|
||||
self.retire_inactive(control)?;
|
||||
let mut next = self.current().clone();
|
||||
next.sequence += 1;
|
||||
let block = if payload.is_empty() {
|
||||
None
|
||||
} else {
|
||||
let mut protected = self.known_quarantine;
|
||||
for m in self.maps.iter().flatten() {
|
||||
for s in &m.slots {
|
||||
if let Some(b) = s.block {
|
||||
protected[b as usize] = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
let id =
|
||||
*next.order.iter().find(|&&id| !protected[id as usize]).ok_or(Error::NoSpace)?;
|
||||
control.check()?;
|
||||
self.io.write_at(block_offset(id)?, payload)?;
|
||||
self.io.sync()?;
|
||||
control.check()?;
|
||||
self.io.read_at(block_offset(id)?, &mut self.scratch[..payload.len()])?;
|
||||
if self.scratch[..payload.len()] != *payload {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
Some(id)
|
||||
};
|
||||
if let Some(id) = block {
|
||||
move_last(&mut next.order, id)
|
||||
}
|
||||
if let Some(id) = old.block {
|
||||
move_last(&mut next.order, id)
|
||||
}
|
||||
next.slots[slot] = Slot {
|
||||
assigned: true,
|
||||
block,
|
||||
used: payload.len() as u32,
|
||||
generation,
|
||||
update_at: timestamp,
|
||||
crc: crc32c(payload),
|
||||
};
|
||||
self.publish(next, control)
|
||||
}
|
||||
/// Runtime-authorized catalog mutation; userland cannot provide global ownership.
|
||||
/// Existing icon data streams between copies through the single scratch buffer.
|
||||
pub fn publish_catalog(
|
||||
&mut self,
|
||||
mut catalog: Catalog,
|
||||
slots: [Slot; SLOT_COUNT],
|
||||
new_icon: Option<(u32, &[u8])>,
|
||||
control: &PublicationControl,
|
||||
) -> Result<()> {
|
||||
self.writable()?;
|
||||
self.attempted_publication = None;
|
||||
control.check()?;
|
||||
let mut next = self.current().clone();
|
||||
next.sequence += 1;
|
||||
next.public_copy = 1 - next.public_copy;
|
||||
next.slots = slots;
|
||||
let mut offset = 0usize;
|
||||
for game in &mut catalog.games {
|
||||
let len = game.icon.length()?;
|
||||
game.icon.offset = offset as u32;
|
||||
offset = offset.checked_add(len).ok_or(Error::NoSpace)?;
|
||||
}
|
||||
catalog.validate(offset)?;
|
||||
let raw = catalog.encode(offset)?;
|
||||
let assigned = catalog.validate(offset)?;
|
||||
if slots.iter().zip(assigned).any(|(s, a)| s.assigned != a) {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
next.catalog_len = raw.len() as u32;
|
||||
next.catalog_crc = crc32c(&raw);
|
||||
next.icons_len = offset as u32;
|
||||
// Reject invalid descriptors before any administrative IO.
|
||||
next.encode()?;
|
||||
self.retire_inactive(control)?;
|
||||
let mut crc = !0;
|
||||
for game in &catalog.games {
|
||||
control.check()?;
|
||||
let len = game.icon.length()?;
|
||||
if let Some((id, bytes)) = new_icon.filter(|(id, _)| *id == game.app_id) {
|
||||
let _ = id;
|
||||
if bytes.len() != len || crc32c(bytes) != game.icon.crc32c {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
self.scratch[..len].copy_from_slice(bytes);
|
||||
} else {
|
||||
let old = self
|
||||
.catalog
|
||||
.games
|
||||
.iter()
|
||||
.find(|g| g.app_id == game.app_id)
|
||||
.ok_or(Error::InvalidRange)?;
|
||||
if old.icon.length()? != len || old.icon.crc32c != game.icon.crc32c {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
self.io.read_at(
|
||||
ICON_OFFSETS[self.current().public_copy] + old.icon.offset as u64,
|
||||
&mut self.scratch[..len],
|
||||
)?;
|
||||
if crc32c(&self.scratch[..len]) != old.icon.crc32c {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
}
|
||||
crc = crc_extend(crc, &self.scratch[..len]);
|
||||
self.io.write_at(
|
||||
ICON_OFFSETS[next.public_copy] + game.icon.offset as u64,
|
||||
&self.scratch[..len],
|
||||
)?;
|
||||
}
|
||||
next.icons_crc = crc ^ !0;
|
||||
write_region(self.io.as_mut(), CATALOG_OFFSETS[next.public_copy], &raw)?;
|
||||
self.io.sync()?;
|
||||
Self::validate_map(self.io.as_mut(), &next, self.scratch.as_mut())?;
|
||||
self.publish(next, control)?;
|
||||
self.catalog = catalog;
|
||||
Ok(())
|
||||
}
|
||||
pub fn register(
|
||||
&mut self,
|
||||
mut game: Game,
|
||||
icon: &[u8],
|
||||
control: &PublicationControl,
|
||||
) -> Result<()> {
|
||||
if self.catalog.games.iter().any(|g| g.app_id == game.app_id) {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
let n = game.slots.len();
|
||||
if !(1..=64).contains(&n) {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
let mut slots = self.current().slots;
|
||||
let free: Vec<u8> = slots
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, s)| !s.assigned)
|
||||
.map(|(i, _)| i as u8)
|
||||
.take(n)
|
||||
.collect();
|
||||
if free.len() != n {
|
||||
return Err(Error::NoSpace);
|
||||
}
|
||||
game.slots = free;
|
||||
for &id in &game.slots {
|
||||
slots[id as usize] = Slot { assigned: true, ..Slot::default() };
|
||||
}
|
||||
let app_id = game.app_id;
|
||||
let mut c = self.catalog.clone();
|
||||
c.games.push(game);
|
||||
self.publish_catalog(c, slots, Some((app_id, icon)), control)
|
||||
}
|
||||
pub fn remove_game(&mut self, app_id: u32, control: &PublicationControl) -> Result<()> {
|
||||
let game =
|
||||
self.catalog.games.iter().find(|g| g.app_id == app_id).ok_or(Error::InvalidRange)?;
|
||||
let mut slots = self.current().slots;
|
||||
for &id in &game.slots {
|
||||
slots[id as usize] = Slot::default();
|
||||
}
|
||||
let mut c = self.catalog.clone();
|
||||
c.games.retain(|g| g.app_id != app_id);
|
||||
self.publish_catalog(c, slots, None, control)
|
||||
}
|
||||
pub fn grow(&mut self, app_id: u32, count: usize, control: &PublicationControl) -> Result<()> {
|
||||
if !(1..=64).contains(&count) {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
let mut c = self.catalog.clone();
|
||||
let g = c.games.iter_mut().find(|g| g.app_id == app_id).ok_or(Error::InvalidRange)?;
|
||||
if count <= g.slots.len() {
|
||||
return Ok(());
|
||||
}
|
||||
let need = count - g.slots.len();
|
||||
let mut slots = self.current().slots;
|
||||
let free: Vec<u8> = slots
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter(|(_, s)| !s.assigned)
|
||||
.map(|(i, _)| i as u8)
|
||||
.take(need)
|
||||
.collect();
|
||||
if free.len() != need {
|
||||
return Err(Error::NoSpace);
|
||||
}
|
||||
for &id in &free {
|
||||
slots[id as usize] = Slot { assigned: true, ..Slot::default() };
|
||||
}
|
||||
g.slots.extend(free);
|
||||
self.publish_catalog(c, slots, None, control)
|
||||
}
|
||||
/// Explicit host maintenance after coherent mount. Unknown exclusion history
|
||||
/// can only be cleared after every reusable, non-quarantined block is tested.
|
||||
pub fn revalidate(&mut self, control: &PublicationControl) -> Result<()> {
|
||||
if self.uncertain {
|
||||
return Err(Error::Indeterminate);
|
||||
}
|
||||
if self.io.read_only() {
|
||||
return Err(Error::ReadOnly);
|
||||
}
|
||||
if self.current().sequence == u64::MAX {
|
||||
return Err(Error::CounterExhausted);
|
||||
}
|
||||
self.write_blocked = true;
|
||||
self.retire_inactive(control)?;
|
||||
for block in 0..BLOCK_COUNT {
|
||||
if !self.known_quarantine[block]
|
||||
&& !self.current().slots.iter().any(|s| s.block == Some(block as u8))
|
||||
{
|
||||
self.test_free_block(block as u8, control)?;
|
||||
}
|
||||
}
|
||||
let mut next = self.current().clone();
|
||||
next.sequence += 1;
|
||||
next.quarantine = self.known_quarantine;
|
||||
self.publish(next, control)?;
|
||||
self.write_blocked = false;
|
||||
self.degraded = self.known_quarantine.iter().any(|&bad| bad);
|
||||
Ok(())
|
||||
}
|
||||
fn test_free_block(&mut self, block: u8, control: &PublicationControl) -> Result<()> {
|
||||
for pattern in [0x55, 0xaa] {
|
||||
control.check()?;
|
||||
self.scratch.fill(pattern);
|
||||
self.io.write_at(block_offset(block)?, self.scratch.as_ref())?;
|
||||
self.io.sync()?;
|
||||
control.check()?;
|
||||
self.io.read_at(block_offset(block)?, self.scratch.as_mut())?;
|
||||
if self.scratch.iter().any(|&byte| byte != pattern) {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Reintegrating a known excluded block is a separate, explicit operation.
|
||||
pub fn reintegrate(&mut self, block: u8, control: &PublicationControl) -> Result<()> {
|
||||
self.writable()?;
|
||||
if block as usize >= BLOCK_COUNT
|
||||
|| self.current().slots.iter().any(|s| s.block == Some(block))
|
||||
{
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
self.retire_inactive(control)?;
|
||||
self.test_free_block(block, control)?;
|
||||
let mut next = self.current().clone();
|
||||
next.sequence += 1;
|
||||
next.quarantine[block as usize] = false;
|
||||
self.publish(next, control)?;
|
||||
self.known_quarantine[block as usize] = false;
|
||||
self.degraded = self.known_quarantine.iter().any(|&bad| bad);
|
||||
Ok(())
|
||||
}
|
||||
pub fn read_icon(&mut self, app_id: u32) -> Result<Vec<u8>> {
|
||||
let icon = &self
|
||||
.catalog
|
||||
.games
|
||||
.iter()
|
||||
.find(|g| g.app_id == app_id)
|
||||
.ok_or(Error::InvalidRange)?
|
||||
.icon;
|
||||
let mut bytes = vec![0; icon.length()?];
|
||||
self.io
|
||||
.read_at(ICON_OFFSETS[self.current().public_copy] + icon.offset as u64, &mut bytes)?;
|
||||
if crc32c(&bytes) != icon.crc32c {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
Ok(bytes)
|
||||
}
|
||||
pub fn quarantine(&mut self, block: u8, control: &PublicationControl) -> Result<()> {
|
||||
if block as usize >= BLOCK_COUNT {
|
||||
return Err(Error::InvalidRange);
|
||||
}
|
||||
self.known_quarantine[block as usize] = true;
|
||||
self.degraded = true;
|
||||
let result = (|| {
|
||||
self.writable()?;
|
||||
if self.current().slots.iter().any(|s| s.block == Some(block)) {
|
||||
return Err(Error::Corrupt);
|
||||
}
|
||||
self.retire_inactive(control)?;
|
||||
let mut next = self.current().clone();
|
||||
next.sequence += 1;
|
||||
next.quarantine = self.known_quarantine;
|
||||
self.publish(next, control)
|
||||
})();
|
||||
if result.is_err() {
|
||||
self.write_blocked = true;
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
fn move_last(order: &mut [u8; BLOCK_COUNT], id: u8) {
|
||||
let pos = order.iter().position(|&b| b == id).unwrap();
|
||||
order[pos..].rotate_left(1);
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
Reference in New Issue
Block a user