sim: Rename `SimFlashMap` to `SimMultiFlash`
The name `SimFlashMap` is a bit misleading, as the Map part is more of
an implementation detail when the type really just represents multiple
flash devices.
This is just a rename, but the names `SimFlashMap` and the value
`flashmap` occur in a lot of places in the image module.
Signed-off-by: David Brown <david.brown@linaro.org>
diff --git a/sim/mcuboot-sys/src/c.rs b/sim/mcuboot-sys/src/c.rs
index ab5548f..d53dc23 100644
--- a/sim/mcuboot-sys/src/c.rs
+++ b/sim/mcuboot-sys/src/c.rs
@@ -1,7 +1,7 @@
/// Interface wrappers to C API entering to the bootloader
use crate::area::AreaDesc;
-use simflash::SimFlashMap;
+use simflash::SimMultiFlash;
use lazy_static::lazy_static;
use libc;
use crate::api;
@@ -14,12 +14,12 @@
}
/// Invoke the bootloader on this flash device.
-pub fn boot_go(flashmap: &mut SimFlashMap, areadesc: &AreaDesc,
+pub fn boot_go(multiflash: &mut SimMultiFlash, areadesc: &AreaDesc,
counter: Option<&mut i32>, catch_asserts: bool) -> (i32, u8) {
let _lock = BOOT_LOCK.lock().unwrap();
unsafe {
- for (&dev_id, flash) in flashmap.iter_mut() {
+ for (&dev_id, flash) in multiflash.iter_mut() {
api::set_flash(dev_id, flash);
}
raw::c_catch_asserts = if catch_asserts { 1 } else { 0 };
@@ -33,7 +33,7 @@
let asserts = unsafe { raw::c_asserts };
unsafe {
counter.map(|c| *c = raw::flash_counter as i32);
- for (&dev_id, _) in flashmap {
+ for (&dev_id, _) in multiflash {
api::clear_flash(dev_id);
}
};
diff --git a/sim/simflash/src/lib.rs b/sim/simflash/src/lib.rs
index cd074c9..7500464 100644
--- a/sim/simflash/src/lib.rs
+++ b/sim/simflash/src/lib.rs
@@ -135,7 +135,7 @@
}
-pub type SimFlashMap = HashMap<u8, SimFlash>;
+pub type SimMultiFlash = HashMap<u8, SimFlash>;
impl Flash for SimFlash {
/// The flash drivers tend to erase beyond the bounds of the given range. Instead, we'll be
diff --git a/sim/src/image.rs b/sim/src/image.rs
index bf51a3f..5091608 100644
--- a/sim/src/image.rs
+++ b/sim/src/image.rs
@@ -16,7 +16,7 @@
},
};
-use simflash::{Flash, SimFlash, SimFlashMap};
+use simflash::{Flash, SimFlash, SimMultiFlash};
use mcuboot_sys::{c, AreaDesc, FlashId};
use crate::{
ALL_DEVICES,
@@ -31,16 +31,16 @@
/// the flash simulator(s) and the information about the slots.
#[derive(Clone)]
pub struct ImagesBuilder {
- flashmap: SimFlashMap,
+ multiflash: SimMultiFlash,
areadesc: AreaDesc,
slots: [SlotInfo; 2],
}
/// Images represents the state of a simulation for a given set of images.
-/// The flashmap holds the state of the simulated flash, whereas primaries
+/// The multiflash holds the state of the simulated flash, whereas primaries
/// and upgrades hold the expected contents of these images.
pub struct Images {
- flashmap: SimFlashMap,
+ multiflash: SimMultiFlash,
areadesc: AreaDesc,
slots: [SlotInfo; 2],
primaries: ImageData,
@@ -58,7 +58,7 @@
impl ImagesBuilder {
pub fn new(device: DeviceName, align: u8, erased_val: u8) -> Self {
- let (flashmap, areadesc) = Self::make_device(device, align, erased_val);
+ let (multiflash, areadesc) = Self::make_device(device, align, erased_val);
let (slot0_base, slot0_len, slot0_dev_id) = areadesc.find(FlashId::Image0);
let (slot1_base, slot1_len, slot1_dev_id) = areadesc.find(FlashId::Image1);
@@ -83,7 +83,7 @@
};
ImagesBuilder {
- flashmap: flashmap,
+ multiflash: multiflash,
areadesc: areadesc,
slots: [slot0, slot1],
}
@@ -104,11 +104,11 @@
/// Construct an `Images` that doesn't expect an upgrade to happen.
pub fn make_no_upgrade_image(self) -> Images {
- let mut flashmap = self.flashmap;
- let primaries = install_image(&mut flashmap, &self.slots, 0, 32784, false);
- let upgrades = install_image(&mut flashmap, &self.slots, 1, 41928, false);
+ let mut multiflash = self.multiflash;
+ let primaries = install_image(&mut multiflash, &self.slots, 0, 32784, false);
+ let upgrades = install_image(&mut multiflash, &self.slots, 1, 41928, false);
Images {
- flashmap: flashmap,
+ multiflash: multiflash,
areadesc: self.areadesc,
slots: self.slots,
primaries: primaries,
@@ -120,7 +120,7 @@
/// Construct an `Images` for normal testing.
pub fn make_image(self) -> Images {
let mut images = self.make_no_upgrade_image();
- mark_upgrade(&mut images.flashmap, &images.slots[1]);
+ mark_upgrade(&mut images.multiflash, &images.slots[1]);
// upgrades without fails, counts number of flash operations
let total_count = match images.run_basic_upgrade() {
@@ -135,11 +135,11 @@
}
pub fn make_bad_slot1_image(self) -> Images {
- let mut bad_flashmap = self.flashmap;
- let primaries = install_image(&mut bad_flashmap, &self.slots, 0, 32784, false);
- let upgrades = install_image(&mut bad_flashmap, &self.slots, 1, 41928, true);
+ let mut bad_multiflash = self.multiflash;
+ let primaries = install_image(&mut bad_multiflash, &self.slots, 0, 32784, false);
+ let upgrades = install_image(&mut bad_multiflash, &self.slots, 1, 41928, true);
Images {
- flashmap: bad_flashmap,
+ multiflash: bad_multiflash,
areadesc: self.areadesc,
slots: self.slots,
primaries: primaries,
@@ -149,7 +149,7 @@
}
/// Build the Flash and area descriptor for a given device.
- pub fn make_device(device: DeviceName, align: u8, erased_val: u8) -> (SimFlashMap, AreaDesc) {
+ pub fn make_device(device: DeviceName, align: u8, erased_val: u8) -> (SimMultiFlash, AreaDesc) {
match device {
DeviceName::Stm32f4 => {
// STM style flash. Large sectors, with a large scratch area.
@@ -164,9 +164,9 @@
areadesc.add_image(0x040000, 0x020000, FlashId::Image1, dev_id);
areadesc.add_image(0x060000, 0x020000, FlashId::ImageScratch, dev_id);
- let mut flashmap = SimFlashMap::new();
- flashmap.insert(dev_id, flash);
- (flashmap, areadesc)
+ let mut multiflash = SimMultiFlash::new();
+ multiflash.insert(dev_id, flash);
+ (multiflash, areadesc)
}
DeviceName::K64f => {
// NXP style flash. Small sectors, one small sector for scratch.
@@ -179,9 +179,9 @@
areadesc.add_image(0x040000, 0x020000, FlashId::Image1, dev_id);
areadesc.add_image(0x060000, 0x001000, FlashId::ImageScratch, dev_id);
- let mut flashmap = SimFlashMap::new();
- flashmap.insert(dev_id, flash);
- (flashmap, areadesc)
+ let mut multiflash = SimMultiFlash::new();
+ multiflash.insert(dev_id, flash);
+ (multiflash, areadesc)
}
DeviceName::K64fBig => {
// Simulating an STM style flash on top of an NXP style flash. Underlying flash device
@@ -195,9 +195,9 @@
areadesc.add_simple_image(0x040000, 0x020000, FlashId::Image1, dev_id);
areadesc.add_simple_image(0x060000, 0x020000, FlashId::ImageScratch, dev_id);
- let mut flashmap = SimFlashMap::new();
- flashmap.insert(dev_id, flash);
- (flashmap, areadesc)
+ let mut multiflash = SimMultiFlash::new();
+ multiflash.insert(dev_id, flash);
+ (multiflash, areadesc)
}
DeviceName::Nrf52840 => {
// Simulating the flash on the nrf52840 with partitions set up so that the scratch size
@@ -211,9 +211,9 @@
areadesc.add_image(0x03c000, 0x034000, FlashId::Image1, dev_id);
areadesc.add_image(0x070000, 0x00d000, FlashId::ImageScratch, dev_id);
- let mut flashmap = SimFlashMap::new();
- flashmap.insert(dev_id, flash);
- (flashmap, areadesc)
+ let mut multiflash = SimMultiFlash::new();
+ multiflash.insert(dev_id, flash);
+ (multiflash, areadesc)
}
DeviceName::Nrf52840SpiFlash => {
// Simulate nrf52840 with external SPI flash. The external SPI flash
@@ -229,10 +229,10 @@
areadesc.add_image(0x000000, 0x068000, FlashId::Image1, 1);
areadesc.add_image(0x068000, 0x018000, FlashId::ImageScratch, 1);
- let mut flashmap = SimFlashMap::new();
- flashmap.insert(0, flash0);
- flashmap.insert(1, flash1);
- (flashmap, areadesc)
+ let mut multiflash = SimMultiFlash::new();
+ multiflash.insert(0, flash0);
+ multiflash.insert(1, flash1);
+ (multiflash, areadesc)
}
}
}
@@ -244,10 +244,10 @@
/// Returns the number of flash operations which can later be used to
/// inject failures at chosen steps.
pub fn run_basic_upgrade(&self) -> Result<i32, ()> {
- let (flashmap, total_count) = try_upgrade(&self.flashmap, &self, None);
+ let (multiflash, total_count) = try_upgrade(&self.multiflash, &self, None);
info!("Total flash operation count={}", total_count);
- if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.upgrades) {
warn!("Image mismatch after first boot");
Err(())
} else {
@@ -266,8 +266,8 @@
if Caps::SwapUpgrade.present() {
for count in 2 .. 5 {
info!("Try revert: {}", count);
- let flashmap = try_revert(&self.flashmap, &self.areadesc, count);
- if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+ let multiflash = try_revert(&self.multiflash, &self.areadesc, count);
+ if !verify_image(&multiflash, &self.slots, 0, &self.primaries) {
error!("Revert failure on count {}", count);
fails += 1;
}
@@ -284,27 +284,27 @@
// Let's try an image halfway through.
for i in 1 .. total_flash_ops {
info!("Try interruption at {}", i);
- let (flashmap, count) = try_upgrade(&self.flashmap, &self, Some(i));
+ let (multiflash, count) = try_upgrade(&self.multiflash, &self, Some(i));
info!("Second boot, count={}", count);
- if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.upgrades) {
warn!("FAIL at step {} of {}", i, total_flash_ops);
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &self.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 1");
fails += 1;
}
if Caps::SwapUpgrade.present() {
- if !verify_image(&flashmap, &self.slots, 1, &self.primaries) {
+ if !verify_image(&multiflash, &self.slots, 1, &self.primaries) {
warn!("Slot 1 FAIL at step {} of {}", i, total_flash_ops);
fails += 1;
}
@@ -326,13 +326,13 @@
pub fn run_perm_with_random_fails(&self, total_fails: usize) -> bool {
let mut fails = 0;
let total_flash_ops = self.total_count.unwrap();
- let (flashmap, total_counts) = try_random_fails(&self.flashmap, &self,
+ let (multiflash, total_counts) = try_random_fails(&self.multiflash, &self,
total_flash_ops, total_fails);
info!("Random interruptions at reset points={:?}", total_counts);
- let slot0_ok = verify_image(&flashmap, &self.slots, 0, &self.upgrades);
+ let slot0_ok = verify_image(&multiflash, &self.slots, 0, &self.upgrades);
let slot1_ok = if Caps::SwapUpgrade.present() {
- verify_image(&flashmap, &self.slots, 1, &self.primaries)
+ verify_image(&multiflash, &self.slots, 1, &self.primaries)
} else {
true
};
@@ -342,12 +342,12 @@
if slot1_ok { "ok" } else { "fail" });
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
error!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &self.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
error!("Mismatched trailer for Slot 1");
fails += 1;
@@ -370,7 +370,7 @@
if Caps::SwapUpgrade.present() {
for i in 1 .. (self.total_count.unwrap() - 1) {
info!("Try interruption at {}", i);
- if try_revert_with_fail_at(&self.flashmap, &self, i) {
+ if try_revert_with_fail_at(&self.multiflash, &self, i) {
error!("Revert failed at interruption {}", i);
fails += 1;
}
@@ -385,13 +385,13 @@
return false;
}
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
info!("Try norevert");
// First do a normal upgrade...
- let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+ let (result, _) = c::boot_go(&mut multiflash, &self.areadesc, None, false);
if result != 0 {
warn!("Failed first boot");
fails += 1;
@@ -400,42 +400,42 @@
//FIXME: copy_done is written by boot_go, is it ok if no copy
// was ever done?
- if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.upgrades) {
warn!("Slot 0 image verification FAIL");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_UNSET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &self.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 1");
fails += 1;
}
// Marks image in slot0 as permanent, no revert should happen...
- mark_permanent_upgrade(&mut flashmap, &self.slots[0]);
+ mark_permanent_upgrade(&mut multiflash, &self.slots[0]);
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+ let (result, _) = c::boot_go(&mut multiflash, &self.areadesc, None, false);
if result != 0 {
warn!("Failed second boot");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.upgrades) {
warn!("Failed image verification");
fails += 1;
}
@@ -450,38 +450,38 @@
// Tests a new image written to slot0 that already has magic and image_ok set
// while there is no image on slot1, so no revert should ever happen...
pub fn run_norevert_newimage(&self) -> bool {
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
info!("Try non-revert on imgtool generated image");
- mark_upgrade(&mut flashmap, &self.slots[0]);
+ mark_upgrade(&mut multiflash, &self.slots[0]);
// This simulates writing an image created by imgtool to Slot 0
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
// Run the bootloader...
- let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+ let (result, _) = c::boot_go(&mut multiflash, &self.areadesc, None, false);
if result != 0 {
warn!("Failed first boot");
fails += 1;
}
// State should not have changed
- if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.primaries) {
warn!("Failed image verification");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &self.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 1");
fails += 1;
@@ -497,34 +497,34 @@
// Tests a new image written to slot0 that already has magic and image_ok set
// while there is no image on slot1, so no revert should ever happen...
pub fn run_signfail_upgrade(&self) -> bool {
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
info!("Try upgrade image with bad signature");
- mark_upgrade(&mut flashmap, &self.slots[0]);
- mark_permanent_upgrade(&mut flashmap, &self.slots[0]);
- mark_upgrade(&mut flashmap, &self.slots[1]);
+ mark_upgrade(&mut multiflash, &self.slots[0]);
+ mark_permanent_upgrade(&mut multiflash, &self.slots[0]);
+ mark_upgrade(&mut multiflash, &self.slots[1]);
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
// Run the bootloader...
- let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+ let (result, _) = c::boot_go(&mut multiflash, &self.areadesc, None, false);
if result != 0 {
warn!("Failed first boot");
fails += 1;
}
// State should not have changed
- if !verify_image(&flashmap, &self.slots, 0, &self.primaries) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.primaries) {
warn!("Failed image verification");
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
@@ -560,15 +560,15 @@
return false;
}
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
info!("Try swap with status fails");
- mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
- self.mark_bad_status_with_rate(&mut flashmap, 0, 1.0);
+ mark_permanent_upgrade(&mut multiflash, &self.slots[1]);
+ self.mark_bad_status_with_rate(&mut multiflash, 0, 1.0);
- let (result, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+ let (result, asserts) = c::boot_go(&mut multiflash, &self.areadesc, None, true);
if result != 0 {
warn!("Failed!");
fails += 1;
@@ -581,19 +581,19 @@
fails += 1;
}
- if !verify_trailer(&flashmap, &self.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &self.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0");
fails += 1;
}
- if !verify_image(&flashmap, &self.slots, 0, &self.upgrades) {
+ if !verify_image(&multiflash, &self.slots, 0, &self.upgrades) {
warn!("Failed image verification");
fails += 1;
}
info!("validate slot0 enabled; re-run of boot_go should just work");
- let (result, _) = c::boot_go(&mut flashmap, &self.areadesc, None, false);
+ let (result, _) = c::boot_go(&mut multiflash, &self.areadesc, None, false);
if result != 0 {
warn!("Failed!");
fails += 1;
@@ -614,7 +614,7 @@
false
} else if Caps::ValidateSlot0.present() {
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
let mut count = self.total_count.unwrap() / 2;
@@ -622,20 +622,20 @@
info!("Try interrupted swap with status fails");
- mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
- self.mark_bad_status_with_rate(&mut flashmap, 0, 0.5);
+ mark_permanent_upgrade(&mut multiflash, &self.slots[1]);
+ self.mark_bad_status_with_rate(&mut multiflash, 0, 0.5);
// Should not fail, writing to bad regions does not assert
- let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, Some(&mut count), true);
+ let (_, asserts) = c::boot_go(&mut multiflash, &self.areadesc, Some(&mut count), true);
if asserts != 0 {
warn!("At least one assert() was called");
fails += 1;
}
- self.reset_bad_status(&mut flashmap, 0);
+ self.reset_bad_status(&mut multiflash, 0);
info!("Resuming an interrupted swap operation");
- let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+ let (_, asserts) = c::boot_go(&mut multiflash, &self.areadesc, None, true);
// This might throw no asserts, for large sector devices, where
// a single failure writing is indistinguishable from no failure,
@@ -652,16 +652,16 @@
fails > 0
} else {
- let mut flashmap = self.flashmap.clone();
+ let mut multiflash = self.multiflash.clone();
let mut fails = 0;
info!("Try interrupted swap with status fails");
- mark_permanent_upgrade(&mut flashmap, &self.slots[1]);
- self.mark_bad_status_with_rate(&mut flashmap, 0, 1.0);
+ mark_permanent_upgrade(&mut multiflash, &self.slots[1]);
+ self.mark_bad_status_with_rate(&mut multiflash, 0, 1.0);
// This is expected to fail while writing to bad regions...
- let (_, asserts) = c::boot_go(&mut flashmap, &self.areadesc, None, true);
+ let (_, asserts) = c::boot_go(&mut multiflash, &self.areadesc, None, true);
if asserts == 0 {
warn!("No assert() detected");
fails += 1;
@@ -672,14 +672,14 @@
}
/// Adds a new flash area that fails statistically
- fn mark_bad_status_with_rate(&self, flashmap: &mut SimFlashMap, slot: usize,
+ fn mark_bad_status_with_rate(&self, multiflash: &mut SimMultiFlash, slot: usize,
rate: f32) {
if Caps::OverwriteUpgrade.present() {
return;
}
let dev_id = &self.slots[slot].dev_id;
- let flash = flashmap.get_mut(&dev_id).unwrap();
+ let flash = multiflash.get_mut(&dev_id).unwrap();
let align = flash.align();
let off = &self.slots[0].base_off;
let len = &self.slots[0].len;
@@ -689,13 +689,13 @@
let _ = flash.add_bad_region(status_off, self.status_sz(align), rate);
}
- fn reset_bad_status(&self, flashmap: &mut SimFlashMap, slot: usize) {
+ fn reset_bad_status(&self, multiflash: &mut SimMultiFlash, slot: usize) {
if !Caps::ValidateSlot0.present() {
return;
}
let dev_id = &self.slots[slot].dev_id;
- let flash = flashmap.get_mut(&dev_id).unwrap();
+ let flash = multiflash.get_mut(&dev_id).unwrap();
flash.reset_bad_regions();
// Disabling write verification the only assert triggered by
@@ -707,16 +707,16 @@
/// Test a boot, optionally stopping after 'n' flash options. Returns a count
/// of the number of flash operations done total.
-fn try_upgrade(flashmap: &SimFlashMap, images: &Images,
- stop: Option<i32>) -> (SimFlashMap, i32) {
+fn try_upgrade(multiflash: &SimMultiFlash, images: &Images,
+ stop: Option<i32>) -> (SimMultiFlash, i32) {
// Clone the flash to have a new copy.
- let mut flashmap = flashmap.clone();
+ let mut multiflash = multiflash.clone();
- mark_permanent_upgrade(&mut flashmap, &images.slots[1]);
+ mark_permanent_upgrade(&mut multiflash, &images.slots[1]);
let mut counter = stop.unwrap_or(0);
- let (first_interrupted, count) = match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+ let (first_interrupted, count) = match c::boot_go(&mut multiflash, &images.areadesc, Some(&mut counter), false) {
(-0x13579, _) => (true, stop.unwrap()),
(0, _) => (false, -counter),
(x, _) => panic!("Unknown return: {}", x),
@@ -725,90 +725,90 @@
counter = 0;
if first_interrupted {
// fl.dump();
- match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+ match c::boot_go(&mut multiflash, &images.areadesc, Some(&mut counter), false) {
(-0x13579, _) => panic!("Shouldn't stop again"),
(0, _) => (),
(x, _) => panic!("Unknown return: {}", x),
}
}
- (flashmap, count - counter)
+ (multiflash, count - counter)
}
-fn try_revert(flashmap: &SimFlashMap, areadesc: &AreaDesc, count: usize) -> SimFlashMap {
- let mut flashmap = flashmap.clone();
+fn try_revert(multiflash: &SimMultiFlash, areadesc: &AreaDesc, count: usize) -> SimMultiFlash {
+ let mut multiflash = multiflash.clone();
// fl.write_file("image0.bin").unwrap();
for i in 0 .. count {
info!("Running boot pass {}", i + 1);
- assert_eq!(c::boot_go(&mut flashmap, &areadesc, None, false), (0, 0));
+ assert_eq!(c::boot_go(&mut multiflash, &areadesc, None, false), (0, 0));
}
- flashmap
+ multiflash
}
-fn try_revert_with_fail_at(flashmap: &SimFlashMap, images: &Images,
+fn try_revert_with_fail_at(multiflash: &SimMultiFlash, images: &Images,
stop: i32) -> bool {
- let mut flashmap = flashmap.clone();
+ let mut multiflash = multiflash.clone();
let mut fails = 0;
let mut counter = stop;
- let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false);
+ let (x, _) = c::boot_go(&mut multiflash, &images.areadesc, Some(&mut counter), false);
if x != -0x13579 {
warn!("Should have stopped at interruption point");
fails += 1;
}
- if !verify_trailer(&flashmap, &images.slots, 0, None, None, BOOT_FLAG_UNSET) {
+ if !verify_trailer(&multiflash, &images.slots, 0, None, None, BOOT_FLAG_UNSET) {
warn!("copy_done should be unset");
fails += 1;
}
- let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, None, false);
+ let (x, _) = c::boot_go(&mut multiflash, &images.areadesc, None, false);
if x != 0 {
warn!("Should have finished upgrade");
fails += 1;
}
- if !verify_image(&flashmap, &images.slots, 0, &images.upgrades) {
+ if !verify_image(&multiflash, &images.slots, 0, &images.upgrades) {
warn!("Image in slot 0 before revert is invalid at stop={}", stop);
fails += 1;
}
- if !verify_image(&flashmap, &images.slots, 1, &images.primaries) {
+ if !verify_image(&multiflash, &images.slots, 1, &images.primaries) {
warn!("Image in slot 1 before revert is invalid at stop={}", stop);
fails += 1;
}
- if !verify_trailer(&flashmap, &images.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &images.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_UNSET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 0 before revert");
fails += 1;
}
- if !verify_trailer(&flashmap, &images.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &images.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 1 before revert");
fails += 1;
}
// Do Revert
- let (x, _) = c::boot_go(&mut flashmap, &images.areadesc, None, false);
+ let (x, _) = c::boot_go(&mut multiflash, &images.areadesc, None, false);
if x != 0 {
warn!("Should have finished a revert");
fails += 1;
}
- if !verify_image(&flashmap, &images.slots, 0, &images.primaries) {
+ if !verify_image(&multiflash, &images.slots, 0, &images.primaries) {
warn!("Image in slot 0 after revert is invalid at stop={}", stop);
fails += 1;
}
- if !verify_image(&flashmap, &images.slots, 1, &images.upgrades) {
+ if !verify_image(&multiflash, &images.slots, 1, &images.upgrades) {
warn!("Image in slot 1 after revert is invalid at stop={}", stop);
fails += 1;
}
- if !verify_trailer(&flashmap, &images.slots, 0, BOOT_MAGIC_GOOD,
+ if !verify_trailer(&multiflash, &images.slots, 0, BOOT_MAGIC_GOOD,
BOOT_FLAG_SET, BOOT_FLAG_SET) {
warn!("Mismatched trailer for Slot 1 after revert");
fails += 1;
}
- if !verify_trailer(&flashmap, &images.slots, 1, BOOT_MAGIC_UNSET,
+ if !verify_trailer(&multiflash, &images.slots, 1, BOOT_MAGIC_UNSET,
BOOT_FLAG_UNSET, BOOT_FLAG_UNSET) {
warn!("Mismatched trailer for Slot 1 after revert");
fails += 1;
@@ -817,11 +817,11 @@
fails > 0
}
-fn try_random_fails(flashmap: &SimFlashMap, images: &Images,
- total_ops: i32, count: usize) -> (SimFlashMap, Vec<i32>) {
- let mut flashmap = flashmap.clone();
+fn try_random_fails(multiflash: &SimMultiFlash, images: &Images,
+ total_ops: i32, count: usize) -> (SimMultiFlash, Vec<i32>) {
+ let mut multiflash = multiflash.clone();
- mark_permanent_upgrade(&mut flashmap, &images.slots[1]);
+ mark_permanent_upgrade(&mut multiflash, &images.slots[1]);
let mut rng = rand::thread_rng();
let mut resets = vec![0i32; count];
@@ -830,7 +830,7 @@
let ops = Range::new(1, remaining_ops / 2);
let reset_counter = ops.ind_sample(&mut rng);
let mut counter = reset_counter;
- match c::boot_go(&mut flashmap, &images.areadesc, Some(&mut counter), false) {
+ match c::boot_go(&mut multiflash, &images.areadesc, Some(&mut counter), false) {
(0, _) | (-0x13579, _) => (),
(x, _) => panic!("Unknown return: {}", x),
}
@@ -838,13 +838,13 @@
resets[i] = reset_counter;
}
- match c::boot_go(&mut flashmap, &images.areadesc, None, false) {
+ match c::boot_go(&mut multiflash, &images.areadesc, None, false) {
(-0x13579, _) => panic!("Should not be have been interrupted!"),
(0, _) => (),
(x, _) => panic!("Unknown return: {}", x),
}
- (flashmap, resets)
+ (multiflash, resets)
}
/// Show the flash layout.
@@ -860,7 +860,7 @@
/// Install a "program" into the given image. This fakes the image header, or at least all of the
/// fields used by the given code. Returns a copy of the image that was written.
-fn install_image(flashmap: &mut SimFlashMap, slots: &[SlotInfo], slot: usize, len: usize,
+fn install_image(multiflash: &mut SimMultiFlash, slots: &[SlotInfo], slot: usize, len: usize,
bad_sig: bool) -> ImageData {
let offset = slots[slot].base_off;
let slot_len = slots[slot].len;
@@ -949,7 +949,7 @@
// un-encrypted. In slot1 the image is written un-encrypted, and if
// encryption is requested, it follows an erase + flash encrypted.
- let flash = flashmap.get_mut(&dev_id).unwrap();
+ let flash = multiflash.get_mut(&dev_id).unwrap();
if slot == 0 {
let enc_copy: Option<Vec<u8>>;
@@ -1051,7 +1051,7 @@
}
/// Verify that given image is present in the flash at the given offset.
-fn verify_image(flashmap: &SimFlashMap, slots: &[SlotInfo], slot: usize,
+fn verify_image(multiflash: &SimMultiFlash, slots: &[SlotInfo], slot: usize,
images: &ImageData) -> bool {
let image = images.find(slot);
let buf = image.as_slice();
@@ -1059,7 +1059,7 @@
let mut copy = vec![0u8; buf.len()];
let offset = slots[slot].base_off;
- let flash = flashmap.get(&dev_id).unwrap();
+ let flash = multiflash.get(&dev_id).unwrap();
flash.read(offset, &mut copy).unwrap();
if buf != ©[..] {
@@ -1076,7 +1076,7 @@
}
}
-fn verify_trailer(flashmap: &SimFlashMap, slots: &[SlotInfo], slot: usize,
+fn verify_trailer(multiflash: &SimMultiFlash, slots: &[SlotInfo], slot: usize,
magic: Option<u8>, image_ok: Option<u8>,
copy_done: Option<u8>) -> bool {
if Caps::OverwriteUpgrade.present() {
@@ -1088,7 +1088,7 @@
let mut copy = vec![0u8; c::boot_magic_sz() + c::boot_max_align() * 2];
let mut failed = false;
- let flash = flashmap.get(&dev_id).unwrap();
+ let flash = multiflash.get(&dev_id).unwrap();
let erased_val = flash.erased_val();
flash.read(offset, &mut copy).unwrap();
@@ -1183,16 +1183,16 @@
const BOOT_FLAG_UNSET: Option<u8> = Some(3);
/// Write out the magic so that the loader tries doing an upgrade.
-pub fn mark_upgrade(flashmap: &mut SimFlashMap, slot: &SlotInfo) {
- let flash = flashmap.get_mut(&slot.dev_id).unwrap();
+pub fn mark_upgrade(multiflash: &mut SimMultiFlash, slot: &SlotInfo) {
+ let flash = multiflash.get_mut(&slot.dev_id).unwrap();
let offset = slot.trailer_off + c::boot_max_align() * 2;
flash.write(offset, MAGIC.unwrap()).unwrap();
}
/// Writes the image_ok flag which, guess what, tells the bootloader
/// the this image is ok (not a test, and no revert is to be performed).
-fn mark_permanent_upgrade(flashmap: &mut SimFlashMap, slot: &SlotInfo) {
- let flash = flashmap.get_mut(&slot.dev_id).unwrap();
+fn mark_permanent_upgrade(multiflash: &mut SimMultiFlash, slot: &SlotInfo) {
+ let flash = multiflash.get_mut(&slot.dev_id).unwrap();
let mut ok = [flash.erased_val(); 8];
ok[0] = 1u8;
let off = slot.trailer_off + c::boot_max_align();