partial progress on create-image

create-image can now genereate inis sections

still needs to kick out a `swap` argument for the bootloader
so it knows where swap should go.
This commit is contained in:
bunnie 2024-03-16 02:03:55 +08:00
parent 66779dd479
commit 38f0002294
4 changed files with 202 additions and 1 deletions

View file

@ -42,3 +42,10 @@ name = "read-tags"
[[bin]]
name = "sign-image"
[features]
precursor = []
renode = []
cramium-soc = []
atsama5d2 = []
default = []

View file

@ -11,6 +11,7 @@ use tools::elf::{read_minielf, read_program};
use tools::tags::bflg::Bflg;
use tools::tags::inie::IniE;
use tools::tags::inif::IniF;
use tools::tags::inis::IniS;
use tools::tags::memory::{MemoryRegion, MemoryRegions};
use tools::tags::pnam::ProcessNames;
use tools::tags::xkrn::XousKernel;
@ -25,6 +26,13 @@ struct RamConfig {
memory_required: u32,
}
struct SwapConfig {
offset: u32,
size: u32,
regions: MemoryRegions,
memory_required: u32,
}
fn csr_to_config(hv: tools::utils::CsrConfig, ram_config: &mut RamConfig) {
let mut found_ram_name = None;
fn round_mem(src: u32) -> u32 { (src + 4095) & !4095 }
@ -111,6 +119,14 @@ fn main() {
.number_of_values(1)
.help("Initial program to load from FLASH"),
)
.arg(
Arg::with_name("inis")
.long("inis")
.takes_value(true)
.multiple(true)
.number_of_values(1)
.help("Program to be loaded into swap space"),
)
.arg(
Arg::with_name("csv")
.short("c")
@ -149,6 +165,13 @@ fn main() {
.help("RAM offset and size, in the form of [offset]:[size]")
.required_unless_one(&["ram", "svd", "csv"]),
)
.arg(
Arg::with_name("swap")
.long("swap")
.takes_value(true)
.value_name("OFFSET:SIZE")
.help("Swap offset and size, in the form of [offset]:[size]; note: offset and size have platform-dependent interpretations")
)
.arg(
Arg::with_name("debug")
.short("d")
@ -172,6 +195,13 @@ fn main() {
memory_required: 0,
};
let mut swap_config = SwapConfig {
offset: Default::default(),
size: Default::default(),
regions: MemoryRegions::new(),
memory_required: 0,
};
let mut process_names = ProcessNames::new();
if let Some(val) = matches.value_of("ram") {
@ -285,10 +315,71 @@ fn main() {
csr_to_config(tools::utils::CsrConfig { regions: map }, &mut ram_config);
}
// Swap has an architecture-dependent meaning.
//
// On Precursor, it's only used exclusively for testing, so we apply it as a
// "patch" on top of the RAM area -- it's a specifier for what part
// of RAM should be carved out to use as swap.
//
// On Cramium, the swap region may point to a section of memory-mapped RAM, *or*
// it can point to register-mapped SPI RAM. The distinction is based solely upon
// the starting address. If the starting address is `0`, we assume this is talking
// about register-mapped SPI RAM. If it is non-zero, then we assume this is referring
// to a window that is memory-mapped.
if let Some(val) = matches.value_of("swap") {
let swap_parts: Vec<&str> = val.split(':').collect();
if swap_parts.len() != 2 {
eprintln!("Error: --swap argument should be of the form [offset]:[size]");
return;
}
swap_config.offset = match parse_u32(swap_parts[0]) {
Ok(o) => o,
Err(e) => {
eprintln!("Error: Unable to parse {}: {:?}", swap_parts[0], e);
return;
}
};
swap_config.size = match parse_u32(swap_parts[1]) {
Ok(o) => o,
Err(e) => {
eprintln!("Error: Unable to parse {}: {:?}", swap_parts[1], e);
return;
}
};
swap_config.memory_required += swap_config.size / 4096;
}
let mut args = XousArguments::new(ram_config.offset, ram_config.size, ram_config.name);
if !ram_config.regions.is_empty() {
args.add(ram_config.regions);
if !swap_config.regions.is_empty() {
// now process the swap region.
#[cfg(any(feature = "precursor", feature = "renode"))]
{
// this is slightly janky, but we only use this configuration for testing swap
// so we can impose an artificial rule like "swap must be higher than RAM", instead
// of trying to handle the generic cases like "swap could be anywhere, maybe even
// a window inside RAM, or lower, or multiple fragments, or...".
assert!(
swap_config.offset > ram_config.offset,
"swap is assumed to be at a higher address than RAM"
);
// split the RAM space, if necessary, to accommodate swap
if swap_config.offset < ram_config.offset + ram_config.size {
ram_config.size = swap_config.offset - ram_config.offset;
}
}
// Note that other configurations don't split RAM, since the swap is provisioned directly
// in hardware, and thus, no post-processing is required.
args.add(swap_config.regions);
args.add(ram_config.regions);
} else {
args.add(ram_config.regions);
}
}
if matches.is_present("debug") {
@ -334,6 +425,23 @@ fn main() {
}
}
if let Some(init_paths) = matches.values_of("inis") {
for init_path in init_paths {
let program_name = std::path::Path::new(init_path);
process_names.set(
pid,
program_name
.file_stem()
.expect("program had no name")
.to_str()
.expect("program name is not valid utf-8"),
);
pid += 1;
let init = read_minielf(init_path).expect("couldn't parse init file");
args.add(IniS::new(init.entry_point, init.sections, init.program, init.alignment_offset));
}
}
let xkrn = XousKernel::new(
kernel.text_offset,
kernel.text_size,

85
tools/src/tags/inis.rs Normal file
View file

@ -0,0 +1,85 @@
use std::fmt;
use std::io;
use crate::elf::MiniElfSection;
use crate::xous_arguments::{XousArgument, XousArgumentCode, XousSize};
#[derive(Debug)]
pub struct IniS {
/// Address in flash
load_offset: u32,
/// Virtual address entry point
entrypoint: u32,
/// Array of minielf sections
sections: Vec<MiniElfSection>,
/// Actual program data
data: Vec<u8>,
/// Alignment offset
alignment_offset: usize,
}
impl fmt::Display for IniS {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
" IniS: entrypoint @ {:08x}, loaded from {:08x}. Sections:",
self.entrypoint, self.load_offset
)?;
let mut load_offset = self.load_offset;
for section in &self.sections {
writeln!(f, " Loaded from {:08x} - {}", load_offset, section)?;
load_offset += section.size as u32;
}
Ok(())
}
}
impl IniS {
pub fn new(
entrypoint: u32,
sections: Vec<MiniElfSection>,
mut data: Vec<u8>,
alignment_offset: usize,
) -> IniS {
// pad the data to 4 bytes
while data.len() & 3 != 0 {
data.push(0);
}
IniS { load_offset: 0, entrypoint, sections, data, alignment_offset }
}
}
impl XousArgument for IniS {
fn code(&self) -> XousArgumentCode { u32::from_le_bytes(*b"IniS") }
fn length(&self) -> XousSize { 4 + 4 + (self.sections.len() * 8) as XousSize }
fn finalize(&mut self, offset: usize) -> usize {
self.load_offset = offset as u32;
assert!(offset % crate::tags::PAGE_SIZE == self.alignment_offset, "IniS load offset is not aligned");
self.data = crate::tags::align_data_up(&self.data, 0);
self.data.len()
}
fn last_data(&self) -> &[u8] { &self.data }
fn alignment_offset(&self) -> usize { self.alignment_offset }
fn serialize(&self, output: &mut dyn io::Write) -> io::Result<usize> {
let mut written = 0;
written += output.write(&self.load_offset.to_le_bytes())?;
written += output.write(&self.entrypoint.to_le_bytes())?;
for section in &self.sections {
written += output.write(&section.virt.to_le_bytes())?;
let mut word2 = section.size.to_le_bytes();
word2[3] = section.flags.bits();
written += output.write(&word2)?;
}
Ok(written)
}
}

View file

@ -1,6 +1,7 @@
pub mod bflg;
pub mod inie;
pub mod inif;
pub mod inis;
pub mod memory;
pub mod pnam;
pub mod xkrn;