page-align processes within the kernel image

This commit is contained in:
bunnie 2023-02-07 21:10:23 +08:00
parent fbae0f31f4
commit 9889856ede
9 changed files with 273 additions and 42 deletions

View file

@ -9,6 +9,7 @@ use std::fs::File;
use tools::elf::{read_minielf, read_program}; use tools::elf::{read_minielf, read_program};
use tools::tags::bflg::Bflg; use tools::tags::bflg::Bflg;
use tools::tags::inie::IniE; use tools::tags::inie::IniE;
use tools::tags::inif::IniF;
use tools::tags::memory::{MemoryRegion, MemoryRegions}; use tools::tags::memory::{MemoryRegion, MemoryRegions};
use tools::tags::pnam::ProcessNames; use tools::tags::pnam::ProcessNames;
use tools::tags::xkrn::XousKernel; use tools::tags::xkrn::XousKernel;
@ -87,6 +88,15 @@ fn main() {
.number_of_values(1) .number_of_values(1)
.help("Initial program to load"), .help("Initial program to load"),
) )
.arg(
Arg::with_name("inif")
.short("f")
.long("inif")
.takes_value(true)
.multiple(true)
.number_of_values(1)
.help("Initial program to load from FLASH"),
)
.arg( .arg(
Arg::with_name("csv") Arg::with_name("csv")
.short("c") .short("c")
@ -235,8 +245,8 @@ fn main() {
.expect("unable to read kernel"); .expect("unable to read kernel");
process_names.set(1, "kernel"); process_names.set(1, "kernel");
let mut pid = 2;
if let Some(init_paths) = matches.values_of("init") { if let Some(init_paths) = matches.values_of("init") {
let mut pid = 2;
for init_path in init_paths { for init_path in init_paths {
let program_name = std::path::Path::new(init_path); let program_name = std::path::Path::new(init_path);
process_names.set( process_names.set(
@ -253,6 +263,23 @@ fn main() {
} }
} }
if let Some(init_paths) = matches.values_of("inif") {
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(IniF::new(init.entry_point, init.sections, init.program));
}
}
let xkrn = XousKernel::new( let xkrn = XousKernel::new(
kernel.text_offset, kernel.text_offset,
kernel.text_size, kernel.text_size,

View file

@ -60,6 +60,9 @@ impl XousArgument for IniE {
fn finalize(&mut self, offset: usize) -> usize { fn finalize(&mut self, offset: usize) -> usize {
self.load_offset = offset as u32; self.load_offset = offset as u32;
assert!(offset % crate::tags::PAGE_SIZE == 0, "IniE load offset is not aligned");
self.data = crate::tags::align_data_up(&self.data);
self.data.len() self.data.len()
} }

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

@ -0,0 +1,85 @@
use crate::elf::MiniElfSection;
use crate::xous_arguments::{XousArgument, XousArgumentCode, XousSize};
use std::fmt;
use std::io;
#[derive(Debug)]
pub struct IniF {
/// 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>,
}
impl fmt::Display for IniF {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(
f,
" IniF: 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 IniF {
pub fn new(entrypoint: u32, sections: Vec<MiniElfSection>, mut data: Vec<u8>) -> IniF {
// pad the data to 4 bytes
while data.len() & 3 != 0 {
data.push(0);
}
IniF {
load_offset: 0,
entrypoint,
sections,
data,
}
}
}
impl XousArgument for IniF {
fn code(&self) -> XousArgumentCode {
u32::from_le_bytes(*b"IniF")
}
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;
println!("{:x}", self.load_offset);
assert!(offset % crate::tags::PAGE_SIZE == 0, "IniF load offset is not aligned");
self.data = crate::tags::align_data_up(&self.data);
crate::tags::align_size_up(self.data.len())
}
fn last_data(&self) -> &[u8] {
&self.data
}
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

@ -3,3 +3,24 @@ pub mod inie;
pub mod memory; pub mod memory;
pub mod pnam; pub mod pnam;
pub mod xkrn; pub mod xkrn;
pub mod inif;
pub (crate) const PAGE_SIZE: usize = 4096;
pub fn align_size_up(offset: usize) -> usize {
if offset % PAGE_SIZE == 0 {
offset
} else {
(offset + PAGE_SIZE) & !(PAGE_SIZE - 1)
}
}
pub fn align_data_up(data: &Vec<u8>) -> Vec::<u8> {
if data.len() % PAGE_SIZE == 0 {
data.to_vec()
} else {
let padding = align_size_up(data.len()) - data.len();
let pad = vec![0u8; padding];
(&[&data[..], &pad[..]]).concat().to_vec()
}
}

View file

@ -77,6 +77,10 @@ impl XousArgument for XousKernel {
self.load_offset = offset as u32; self.load_offset = offset as u32;
assert!(self.text_offset > 0xff00_0000, assert!(self.text_offset > 0xff00_0000,
"kernel text section is invalid: 0x{:08x} < 0xff000000 -- was it linked with a linker script?", self.text_offset); "kernel text section is invalid: 0x{:08x} < 0xff000000 -- was it linked with a linker script?", self.text_offset);
assert!(offset % crate::tags::PAGE_SIZE == 0, "XKrn load offset is not aligned");
self.program = crate::tags::align_data_up(&self.program);
self.program.len() self.program.len()
} }

View file

@ -1,5 +1,5 @@
use std::fmt; use std::fmt;
use std::io::{Cursor, Result, Write}; use std::io::{Cursor, Result, Write, Seek};
pub type XousArgumentCode = u32; pub type XousArgumentCode = u32;
pub type XousSize = u32; pub type XousSize = u32;
use crc::{crc16, Hasher16}; use crc::{crc16, Hasher16};
@ -81,7 +81,7 @@ impl XousArguments {
} }
pub fn finalize(&mut self) { pub fn finalize(&mut self) {
let mut running_offset = self.len() as usize; let mut running_offset = crate::tags::align_size_up(self.len() as usize);
for arg in &mut self.arguments { for arg in &mut self.arguments {
running_offset += arg.finalize(running_offset); running_offset += arg.finalize(running_offset);
} }
@ -96,7 +96,7 @@ impl XousArguments {
pub fn write<T>(&mut self, mut w: T) -> Result<()> pub fn write<T>(&mut self, mut w: T) -> Result<()>
where where
T: Write, T: Write + Seek,
{ {
let total_length = self.len(); let total_length = self.len();
@ -156,6 +156,12 @@ impl XousArguments {
w.write_all(tag_data.get_ref())?; w.write_all(tag_data.get_ref())?;
} }
// pad to the nearest page
let pos = w.stream_position()?;
let pad_len = crate::tags::align_size_up(pos as usize) - pos as usize;
let pad = vec![0u8; pad_len];
w.write_all(&pad)?;
// Write any pending data, such as payloads // Write any pending data, such as payloads
for arg in &self.arguments { for arg in &self.arguments {
w.write_all(arg.last_data()) w.write_all(arg.last_data())

View file

@ -22,25 +22,55 @@ impl BuildStream {
} }
} }
#[derive(Debug)]
pub enum CrateSpec { pub enum CrateSpec {
/// name of the crate /// name of the crate
Local(String), Local(String, bool),
/// crates.io: (name of crate, version) /// crates.io: (name of crate, version)
CratesIo(String, String), CratesIo(String, String, bool),
/// a prebuilt package: (name of executable, URL for download) /// a prebuilt package: (name of executable, URL for download)
Prebuilt(String, String), Prebuilt(String, String, bool),
/// a prebuilt binary, done using command line tools /// a prebuilt binary, done using command line tools
BinaryFile(String), BinaryFile(String, bool),
/// an empty entry /// an empty entry
None, None,
} }
impl CrateSpec {
pub fn is_xip(&self) -> bool {
match self {
CrateSpec::Local(_s, xip) => *xip,
CrateSpec::CratesIo(_n, _v, xip) => *xip,
CrateSpec::Prebuilt(_n, _u, xip) => *xip,
CrateSpec::BinaryFile(_path, xip) => *xip,
_ => false
}
}
pub fn set_xip(&mut self, xip: bool) {
*self = match self {
CrateSpec::Local(s, _xip) => CrateSpec::Local(s.to_string(), xip),
CrateSpec::CratesIo(n, v, _xip) => CrateSpec::CratesIo(n.to_string(), v.to_string(), xip),
CrateSpec::Prebuilt(n, u, _xip) => CrateSpec::Prebuilt(n.to_string(), u.to_string(), xip),
CrateSpec::BinaryFile(path, _xip) => CrateSpec::BinaryFile(path.to_string(), xip),
CrateSpec::None => CrateSpec::None,
}
}
pub fn name(&self) -> Option<String> {
match self {
CrateSpec::Local(s, _xip) => Some(s.to_string()),
CrateSpec::CratesIo(n, _v, _xip) => Some(n.to_string()),
CrateSpec::Prebuilt(n, _u, _xip) => Some(n.to_string()),
CrateSpec::BinaryFile(path, _xip) => Some(path.to_string()),
_ => None,
}
}
}
impl Clone for CrateSpec { impl Clone for CrateSpec {
fn clone(&self) -> CrateSpec { fn clone(&self) -> CrateSpec {
match self { match self {
CrateSpec::Local(s) => CrateSpec::Local(s.to_string()), CrateSpec::Local(s, xip) => CrateSpec::Local(s.to_string(), *xip),
CrateSpec::CratesIo(n, v) => CrateSpec::CratesIo(n.to_string(), v.to_string()), CrateSpec::CratesIo(n, v, xip) => CrateSpec::CratesIo(n.to_string(), v.to_string(), *xip),
CrateSpec::Prebuilt(n, u) => CrateSpec::Prebuilt(n.to_string(), u.to_string()), CrateSpec::Prebuilt(n, u, xip) => CrateSpec::Prebuilt(n.to_string(), u.to_string(), *xip),
CrateSpec::BinaryFile(path) => CrateSpec::BinaryFile(path.to_string()), CrateSpec::BinaryFile(path, xip) => CrateSpec::BinaryFile(path.to_string(), *xip),
CrateSpec::None => CrateSpec::None, CrateSpec::None => CrateSpec::None,
} }
} }
@ -52,7 +82,8 @@ impl From<&str> for CrateSpec {
let (name, version) = spec.split_once('@').expect("couldn't parse crate specifier"); let (name, version) = spec.split_once('@').expect("couldn't parse crate specifier");
CrateSpec::CratesIo( CrateSpec::CratesIo(
name.to_string(), name.to_string(),
version.to_string() version.to_string(),
false
) )
// prebuilt crates are specified as "name#url" // prebuilt crates are specified as "name#url"
// i.e. "espeak-embedded#https://ci.betrusted.io/job/espeak-embedded/lastSuccessfulBuild/artifact/target/riscv32imac-unknown-xous-elf/release/" // i.e. "espeak-embedded#https://ci.betrusted.io/job/espeak-embedded/lastSuccessfulBuild/artifact/target/riscv32imac-unknown-xous-elf/release/"
@ -60,16 +91,17 @@ impl From<&str> for CrateSpec {
let (name, url) = spec.split_once('#').expect("couldn't parse crate specifier"); let (name, url) = spec.split_once('#').expect("couldn't parse crate specifier");
CrateSpec::Prebuilt( CrateSpec::Prebuilt(
name.to_string(), name.to_string(),
url.to_string() url.to_string(),
false
) )
// local files are specified as paths, which, at a minimum include one directory separator "/" or "\" // local files are specified as paths, which, at a minimum include one directory separator "/" or "\"
// i.e. "./local_file" // i.e. "./local_file"
// Note that this is after a test for the '#' character, so that disambiguates URL slashes // Note that this is after a test for the '#' character, so that disambiguates URL slashes
// It does mean that files with a '#' character in them are mistaken for URL coded paths, and '@' as remote crates. // It does mean that files with a '#' character in them are mistaken for URL coded paths, and '@' as remote crates.
} else if spec.contains('/') || spec.contains('\\') { } else if spec.contains('/') || spec.contains('\\') {
CrateSpec::BinaryFile(spec.to_string()) CrateSpec::BinaryFile(spec.to_string(), false)
} else { } else {
CrateSpec::Local(spec.to_string()) CrateSpec::Local(spec.to_string(), false)
} }
} }
} }
@ -103,11 +135,11 @@ pub(crate) struct Builder {
impl Builder { impl Builder {
pub fn new() -> Builder { pub fn new() -> Builder {
Builder { Builder {
loader: CrateSpec::Local("loader".to_string()), loader: CrateSpec::Local("loader".to_string(), false),
loader_features: Vec::new(), loader_features: Vec::new(),
loader_key: "devkey/dev.key".into(), loader_key: "devkey/dev.key".into(),
loader_disable_defaults: false, loader_disable_defaults: false,
kernel: CrateSpec::Local("xous-kernel".to_string()), kernel: CrateSpec::Local("xous-kernel".to_string(), false),
kernel_features: Vec::new(), kernel_features: Vec::new(),
kernel_key: "devkey/dev.key".into(), kernel_key: "devkey/dev.key".into(),
kernel_disable_defaults: false, kernel_disable_defaults: false,
@ -189,8 +221,8 @@ impl Builder {
self.stream = BuildStream::Release; self.stream = BuildStream::Release;
self.run_svd2repl = true; self.run_svd2repl = true;
self.utra_target = "renode".to_string(); self.utra_target = "renode".to_string();
self.loader = CrateSpec::Local("loader".to_string()); self.loader = CrateSpec::Local("loader".to_string(), false);
self.kernel = CrateSpec::Local("xous-kernel".to_string()); self.kernel = CrateSpec::Local("xous-kernel".to_string(), false);
self self
} }
/// Configure for precursor targets. This is the default, but it's good practice /// Configure for precursor targets. This is the default, but it's good practice
@ -201,8 +233,8 @@ impl Builder {
self.stream = BuildStream::Release; self.stream = BuildStream::Release;
self.utra_target = format!("precursor-{}", soc_version).to_string(); self.utra_target = format!("precursor-{}", soc_version).to_string();
self.run_svd2repl = false; self.run_svd2repl = false;
self.loader = CrateSpec::Local("loader".to_string()); self.loader = CrateSpec::Local("loader".to_string(), false);
self.kernel = CrateSpec::Local("xous-kernel".to_string()); self.kernel = CrateSpec::Local("xous-kernel".to_string(), false);
self self
} }
@ -220,9 +252,10 @@ impl Builder {
} }
/// Add just one service /// Add just one service
#[allow(dead_code)] pub fn add_service<'a>(&'a mut self, service_spec: &str, xip: bool) -> &'a mut Builder {
pub fn add_service<'a>(&'a mut self, service_spec: &str) -> &'a mut Builder { let mut spec: CrateSpec = service_spec.into();
self.services.push(service_spec.into()); spec.set_xip(xip);
self.services.push(spec);
self self
} }
/// Add a list of services /// Add a list of services
@ -339,8 +372,8 @@ impl Builder {
let mut remote_pkgs = Vec::<(&str, &str)>::new(); let mut remote_pkgs = Vec::<(&str, &str)>::new();
for pkg in packages.iter() { for pkg in packages.iter() {
match pkg { match pkg {
CrateSpec::Local(name) => local_pkgs.push(&name), CrateSpec::Local(name, _xip) => local_pkgs.push(&name),
CrateSpec::CratesIo(name, version) => remote_pkgs.push((&name, &version)), CrateSpec::CratesIo(name, version, _xip) => remote_pkgs.push((&name, &version)),
_ => {}, _ => {},
} }
} }
@ -404,6 +437,50 @@ impl Builder {
Ok(artifacts) Ok(artifacts)
} }
pub fn split_xip(&self, services: Vec<String>) -> (Vec<String>, Vec<String>) {
let mut inie = Vec::<String>::new();
let mut inif = Vec::<String>::new();
for service in services.iter() {
let mut found = false;
for app in self.apps.iter() {
if let Some(n) = &app.name() {
if Path::new(service).file_name().unwrap_or_default().to_str().unwrap_or_default() == n {
if app.is_xip() {
inif.push(service.to_string());
} else {
inie.push(service.to_string());
}
found = true;
continue;
}
}
}
if found {
continue;
}
for serv in self.services.iter() {
if let Some(n) = &serv.name() {
if Path::new(service).file_name().unwrap_or_default().to_str().unwrap_or_default() == n {
if serv.is_xip() {
inif.push(service.to_string());
} else {
inie.push(service.to_string());
}
found = true;
continue;
}
}
}
if found {
continue;
}
// the service wasn't found in any of the other lists, mark it as non-xip
inie.push(service.to_string());
}
assert!(inie.len() + inif.len() == services.len());
(inie, inif)
}
/// Consume the builder and execute the configured build task. This handles dispatching all configurations, /// Consume the builder and execute the configured build task. This handles dispatching all configurations,
/// including renode, hosted, and hardware targets. /// including renode, hosted, and hardware targets.
pub fn build(mut self) -> Result<(), DynError> { pub fn build(mut self) -> Result<(), DynError> {
@ -441,8 +518,8 @@ impl Builder {
let mut app_names = Vec::<String>::new(); let mut app_names = Vec::<String>::new();
for app in self.apps.iter() { for app in self.apps.iter() {
match app { match app {
CrateSpec::Local(name) => app_names.push(name.into()), CrateSpec::Local(name, _xip) => app_names.push(name.into()),
CrateSpec::CratesIo(name, _version) => app_names.push(name.into()), CrateSpec::CratesIo(name, _version, _xip) => app_names.push(name.into()),
_ => {} _ => {}
} }
} }
@ -460,7 +537,7 @@ impl Builder {
// throw a warning if prebuilts are specified for hosted mode // throw a warning if prebuilts are specified for hosted mode
for item in [&self.services[..], &self.apps[..]].concat() { for item in [&self.services[..], &self.apps[..]].concat() {
match item { match item {
CrateSpec::Prebuilt(name, _) => println!("Warning! Pre-built binaries not supported for hosted mode ({})", name), CrateSpec::Prebuilt(name, _, _xip) => println!("Warning! Pre-built binaries not supported for hosted mode ({})", name),
_ => {}, _ => {},
} }
} }
@ -503,7 +580,7 @@ impl Builder {
} else { } else {
// confirm the kernel can build before quitting // confirm the kernel can build before quitting
let _ = self.builder( let _ = self.builder(
&vec![CrateSpec::Local("xous-kernel".into())], &vec![CrateSpec::Local("xous-kernel".into(), false)],
&self.kernel_features, &self.kernel_features,
&target, &target,
self.stream, self.stream,
@ -584,9 +661,11 @@ impl Builder {
services_path.append(&mut self.enumerate_binary_files()?); services_path.append(&mut self.enumerate_binary_files()?);
// --------- package up and sign a binary image ---------- // --------- package up and sign a binary image ----------
let (inie, inif) = self.split_xip(services_path);
let output_bundle = self.create_image( let output_bundle = self.create_image(
&kernel_path[0], &kernel_path[0],
&services_path, &inie,
&inif,
MemorySpec::SvdFile(svd_path) MemorySpec::SvdFile(svd_path)
)?; )?;
println!(); println!();
@ -679,6 +758,7 @@ impl Builder {
&self, &self,
kernel: &String, kernel: &String,
init: &[String], init: &[String],
inif: &[String],
memory_spec: MemorySpec, memory_spec: MemorySpec,
) -> Result<PathBuf, DynError> { ) -> Result<PathBuf, DynError> {
let stream = self.stream.to_str(); let stream = self.stream.to_str();
@ -699,6 +779,11 @@ impl Builder {
args.push(i); args.push(i);
} }
for i in inif {
args.push("--inif");
args.push(i);
}
match memory_spec { match memory_spec {
MemorySpec::SvdFile(ref s) => { MemorySpec::SvdFile(ref s) => {
args.push("--svd"); args.push("--svd");
@ -721,7 +806,7 @@ impl Builder {
let mut paths = Vec::<String>::new(); let mut paths = Vec::<String>::new();
for item in [&self.services[..], &self.apps[..]].concat() { for item in [&self.services[..], &self.apps[..]].concat() {
match item { match item {
CrateSpec::Prebuilt(name, url) => { CrateSpec::Prebuilt(name, url, _xip) => {
let exec_name = format!("target/{}/{}/{}", TARGET_TRIPLE, self.stream.to_str(), name); let exec_name = format!("target/{}/{}/{}", TARGET_TRIPLE, self.stream.to_str(), name);
println!("Fetching {} executable from build server...", name); println!("Fetching {} executable from build server...", name);
let mut exec_file = OpenOptions::new() let mut exec_file = OpenOptions::new()
@ -752,7 +837,7 @@ impl Builder {
let mut paths = Vec::<String>::new(); let mut paths = Vec::<String>::new();
for item in [&self.services[..], &self.apps[..]].concat() { for item in [&self.services[..], &self.apps[..]].concat() {
match item { match item {
CrateSpec::BinaryFile(path) => { CrateSpec::BinaryFile(path, _xip) => {
paths.push(path); paths.push(path);
} }
_ => {} _ => {}

View file

@ -193,10 +193,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.add_services(&get_cratespecs()); .add_services(&get_cratespecs());
builder.add_loader_feature("renode-bypass") builder.add_loader_feature("renode-bypass")
.add_loader_feature("renode-minimal"); .add_loader_feature("renode-minimal");
builder.add_service("net") builder.add_service("net", false)
.add_service("com") .add_service("com", false)
.add_service("llio") .add_service("llio", false)
.add_service("dns"); .add_service("dns", false);
} }
Some("renode-aes-test") => { Some("renode-aes-test") => {
builder.target_renode() builder.target_renode()
@ -207,7 +207,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
builder.target_renode() builder.target_renode()
.add_services(&gfx_base_pkgs.into_iter().map(String::from).collect()) .add_services(&gfx_base_pkgs.into_iter().map(String::from).collect())
.add_services(&get_cratespecs()); .add_services(&get_cratespecs());
builder.add_service("ffi-test"); builder.add_service("ffi-test", false);
builder.add_loader_feature("renode-bypass"); builder.add_loader_feature("renode-bypass");
} }
Some("renode-remote") => { Some("renode-remote") => {
@ -316,7 +316,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
builder.add_services(&pkgs.into_iter().map(String::from).collect()) builder.add_services(&pkgs.into_iter().map(String::from).collect())
.add_apps(&get_cratespecs()) .add_apps(&get_cratespecs())
.add_service("espeak-embedded#https://ci.betrusted.io/job/espeak-embedded/lastSuccessfulBuild/artifact/target/riscv32imac-unknown-xous-elf/release/espeak-embedded") .add_service("espeak-embedded#https://ci.betrusted.io/job/espeak-embedded/lastSuccessfulBuild/artifact/target/riscv32imac-unknown-xous-elf/release/espeak-embedded", false)
.override_locale("en-tts") .override_locale("en-tts")
.add_feature("tts") .add_feature("tts")
.add_feature("braille"); .add_feature("braille");
@ -331,7 +331,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
.add_services(&base_pkgs.into_iter().map(String::from).collect()) .add_services(&base_pkgs.into_iter().map(String::from).collect())
.add_services(&get_cratespecs()); .add_services(&get_cratespecs());
//builder.add_service("usb-test"); //builder.add_service("usb-test");
builder.add_service("usb-device-xous"); builder.add_service("usb-device-xous", false);
} }
Some("pddb-dev") => { Some("pddb-dev") => {
builder.target_precursor(PRECURSOR_SOC_VERSION) builder.target_precursor(PRECURSOR_SOC_VERSION)

View file

@ -32,7 +32,7 @@ pub fn check_project_consistency() -> Result<(), DynError> {
} }
pub fn verify(spec: CrateSpec) -> Result<(), DynError> { pub fn verify(spec: CrateSpec) -> Result<(), DynError> {
if let CrateSpec::CratesIo(name, version) = spec { if let CrateSpec::CratesIo(name, version, _xip) = spec {
let mut cache_path = Path::new(&env::var("CARGO_HOME").unwrap()).to_path_buf(); let mut cache_path = Path::new(&env::var("CARGO_HOME").unwrap()).to_path_buf();
cache_path.push("registry"); cache_path.push("registry");
cache_path.push("src"); cache_path.push("src");