Commit 8a4e23bb authored by David Brown's avatar David Brown Committed by David Brown
Browse files

sim: Basic ram-load test 



Test the basic configuration for ram loading.  Instead of a fixed
address for RAM, the values come dynamically from a thread-local
variable (allowing the tests to run in parallel).  The size of the ram
along with the address of the buffer in the test address space are
passed in this way.

This tests the single-image configurations of ram loading.  Testing
multi-image will take additional work, as the RAM will need to be large
enough for both images, and the second image will need a meaningful
offset address in RAM.

Signed-off-by: default avatarDavid Brown <david.brown@linaro.org>
parent 0dfb810d

boot/bootutil/src/bootutil_priv.h

+20 −1
Original line number Diff line number Diff line
@@ -403,7 +403,26 @@ boot_img_sector_off(const struct boot_loader_state *state, size_t slot, 
#endif  /* !defined(MCUBOOT_USE_FLASH_AREA_GET_SECTORS) */



#ifdef MCUBOOT_RAM_LOAD

#   ifdef __BOOTSIM__



/* Query for the layout of a RAM buffer appropriate for holding the

 * image.  This will be per-test-thread, and therefore must be queried

 * through this call. */

struct bootsim_ram_info {

    uint32_t start;

    uint32_t size;

    uintptr_t base;

};

struct bootsim_ram_info *bootsim_get_ram_info(void);



#define IMAGE_GET_FIELD(field) (bootsim_get_ram_info()->field)

#define IMAGE_RAM_BASE IMAGE_GET_FIELD(base)

#define IMAGE_EXECUTABLE_RAM_START IMAGE_GET_FIELD(start)

#define IMAGE_EXECUTABLE_RAM_SIZE IMAGE_GET_FIELD(size)



#   else

#       define IMAGE_RAM_BASE ((uintptr_t)0)

#   endif



#define LOAD_IMAGE_DATA(hdr, fap, start, output, size)       \

    (memcpy((output),(void*)(IMAGE_RAM_BASE + (hdr)->ih_load_addr + (start)), \

sim/mcuboot-sys/build.rs

+0 −3
Original line number Diff line number Diff line
@@ -60,9 +60,6 @@ fn main() { 


    if ram_load {

        conf.define("MCUBOOT_RAM_LOAD", None);



        conf.define("IMAGE_EXECUTABLE_RAM_START", "0x10000");

        conf.define("IMAGE_EXECUTABLE_RAM_SIZE", "0x10000");

    }



    if direct_xip {

sim/mcuboot-sys/src/api.rs

+37 −0
Original line number Diff line number Diff line
@@ -121,9 +121,20 @@ impl Default for CSimContextPtr { 
    }

}



/// This struct describes the RAM layout of the current device.  It will be stashed, per test

/// thread, and queried by the C code.

#[repr(C)]

#[derive(Debug, Default)]

pub struct BootsimRamInfo {

    pub start: u32,

    pub size: u32,

    pub base: usize,

}



thread_local! {

    pub static THREAD_CTX: RefCell<FlashContext> = RefCell::new(FlashContext::new());

    pub static SIM_CTX: RefCell<CSimContextPtr> = RefCell::new(CSimContextPtr::new());

    pub static RAM_CTX: RefCell<BootsimRamInfo> = RefCell::new(BootsimRamInfo::default());

}



/// Set the flash device to be used by the simulation.  The pointer is unsafely stashed away.
@@ -196,6 +207,32 @@ pub extern fn sim_reset_context() { 
    });

}



#[no_mangle]

pub extern "C" fn bootsim_get_ram_info() -> *const BootsimRamInfo {

    RAM_CTX.with(|ctx| {

        if ctx.borrow().base == 0 {

            // Option is messier to get a pointer out of, so just check if the base has been set to

            // anything.

            panic!("ram info not set, but being used");

        }

        ctx.as_ptr()

    })

}



/// Store a copy of this RAM info.

pub fn set_ram_info(info: BootsimRamInfo) {

    RAM_CTX.with(|ctx| {

        ctx.replace(info);

    });

}



/// Clear out the ram info.

pub fn clear_ram_info() {

    RAM_CTX.with(|ctx| {

        ctx.borrow_mut().base = 0;

    });

}



#[no_mangle]

pub extern fn sim_flash_erase(dev_id: u8, offset: u32, size: u32) -> libc::c_int {

    let mut rc: libc::c_int = -19;

sim/mcuboot-sys/src/lib.rs

+35 −0
Original line number Diff line number Diff line
@@ -10,3 +10,38 @@ pub mod c; 
pub mod api;



pub use crate::area::{AreaDesc, FlashId};



/// For testing the ram load feature, we need to emulate a block of RAM and be able to pass that

/// down to the C code.  The call down to boot_go should go through this object so that the buffer

/// itself is managed properly.

pub struct RamBlock {

    ram: Vec<u8>,

    offset: u32, // 32-bit offset.

}



impl RamBlock {

    pub fn new(size: u32, offset: u32) -> RamBlock {

        RamBlock {

            ram: vec![0; size as usize],

            offset: offset,

        }

    }



    /// Borrow the RAM buffer, with 'offset' being the beginning of the buffer.

    pub fn borrow(&self) -> &[u8] {

        &self.ram

    }



    pub fn invoke<F, R>(&self, act: F) -> R

        where F: FnOnce() -> R

    {

        api::set_ram_info(api::BootsimRamInfo {

            start: self.offset,

            size: self.ram.len() as u32,

            base: &self.ram[0] as *const u8 as usize - self.offset as usize,

        });

        let result = act();

        api::clear_ram_info();

        result

    }

}

sim/src/image.rs

+58 −2
Original line number Diff line number Diff line
@@ -35,7 +35,7 @@ use aes_ctr::{ 
};



use simflash::{Flash, SimFlash, SimMultiFlash};

use mcuboot_sys::{c, AreaDesc, FlashId};

use mcuboot_sys::{c, AreaDesc, FlashId, RamBlock};

use crate::{

    ALL_DEVICES,

    DeviceName,
@@ -53,6 +53,18 @@ use crate::depends::{ 
use crate::tlv::{ManifestGen, TlvGen, TlvFlags};

use typenum::{U32, U16};



/// For testing, use a non-zero offset for the ram-load, to make sure the offset is getting used

/// properly, but the value is not really that important.

const RAM_LOAD_ADDR: u32 = 1024;



fn ram_load_addr() -> u32 {

    if Caps::RamLoad.present() {

        RAM_LOAD_ADDR

    } else {

        0

    }

}



/// A builder for Images.  This describes a single run of the simulator,

/// capturing the configuration of a particular set of devices, including

/// the flash simulator(s) and the information about the slots.
@@ -998,6 +1010,50 @@ impl Images { 
        false

    }



    /// Test the ram-loading.

    pub fn run_ram_load(&self) -> bool {

        if !Caps::RamLoad.present() {

            return false;

        }



        // Clone the flash so we can tell if unchanged.

        let mut flash = self.flash.clone();



        let image = &self.images[0].primaries;



        // Test with the minimal size.



        // First verify that if the RAM is too small, we reject it.

        let ram = RamBlock::new(image.plain.len() as u32 - 1, RAM_LOAD_ADDR);

        let result = ram.invoke(|| c::boot_go(&mut flash, &self.areadesc, None, true));

        if result.success() {

            error!("Failed to detect RAM too small");

            return true;

        }

        drop(ram);



        // TODO: The code will erase the flash if it doesn't fit.  Either verify this, or change

        // this behavior.



        let mut flash = self.flash.clone();



        let ram = RamBlock::new(image.plain.len() as u32, RAM_LOAD_ADDR);

        let result = ram.invoke(|| c::boot_go(&mut flash, &self.areadesc, None, true));

        if !result.success() {

            error!("Failed to ram-load image");

            return true;

        }

        println!("Result: {:?}", result);



        // Verify the image was loaded correctly.

        if ram.borrow() != &image.plain {

            error!("Image not loaded correctly");

            return true;

        }



        false

    }



    /// Adds a new flash area that fails statistically

    fn mark_bad_status_with_rate(&self, flash: &mut SimMultiFlash, slot: usize,

                                 rate: f32) {
@@ -1312,7 +1368,7 @@ fn install_image(flash: &mut SimMultiFlash, slot: &SlotInfo, len: usize, 
    // Generate a boot header.  Note that the size doesn't include the header.

    let header = ImageHeader {

        magic: tlv.get_magic(),

        load_addr: 0,

        load_addr: if Caps::RamLoad.present() { ram_load_addr() } else { 0 },

        hdr_size: HDR_SIZE as u16,

        protect_tlv_size: tlv.protect_size(),

        img_size: len as u32,

CRA Git | Maintained and supported by SUSTech CRA and CCSE