Make ROMFS files and bin files.

Author: thejpster

.github/workflows/rust.yml

@@ -14,6 +14,7 @@ jobs:
         with:
           submodules: true
       - run: rustup target add ${{ matrix.target }}
+      - run: rustup component add llvm-tools-preview
       - run: cargo nbuild binary --target=${{ matrix.target }} --start-address=${{ matrix.start_address }}
       - uses: actions/upload-artifact@v4
         if: ${{success()}}
@@ -22,6 +23,8 @@ jobs:
           if-no-files-found: error
           path: |
             ./target/${{ matrix.target }}/release/neotron-os
+            ./target/${{ matrix.target }}/release/neotron-os.bin
+            ./target/${{ matrix.target }}/release/romfs.bin
   linux-libraries:
     runs-on: ubuntu-latest
     steps:

nbuild/Cargo.lock

@@ -12,4 +12,8 @@ readme = "README.md"
 repository = "https://github.com/neotron-compute/Neotron-OS"
 
 [dependencies]
+chrono = { version = "0.4.39", default-features = false, features = ["std"] }
 clap = { version = "4.5.23", features = ["derive"] }
+embedded-io = { version = "0.6.1", features = ["std"] }
+neotron-api = "0.2.0"
+neotron-romfs = "2.0"

nbuild/Cargo.toml

@@ -2,18 +2,18 @@
 
 /// The ways that spawning `cargo` can fail
 #[derive(Debug)]
-pub enum CargoError {
+pub enum ProcessError {
     SpawnError(std::io::Error),
     RunError(std::process::ExitStatus),
 }
 
-impl std::fmt::Display for CargoError {
+impl std::fmt::Display for ProcessError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            CargoError::SpawnError(error) => write!(f, "Failed to spawn `cargo`: {}", error),
-            CargoError::RunError(exit_status) => write!(
+            ProcessError::SpawnError(error) => write!(f, "Failed to spawn command: {}", error),
+            ProcessError::RunError(exit_status) => write!(
                 f,
-                "Failed to complete `cargo` command ({}). There should be an error above",
+                "Failed to complete command ({}). There should be an error above",
                 exit_status
             ),
         }
@@ -33,9 +33,16 @@ pub enum PackageKind {
 pub struct Package {
     pub name: &'static str,
     pub path: &'static std::path::Path,
-    pub output: &'static std::path::Path,
     pub kind: PackageKind,
     pub testable: bool,
+    pub output_template: Option<&'static str>,
+}
+
+impl Package {
+    pub fn output(&self, target: &str, profile: &str) -> Option<String> {
+        self.output_template
+            .map(|s| s.replace("{target}", target).replace("{profile}", profile))
+    }
 }
 
 /// Parse an integer, with an optional `0x` prefix.
@@ -60,7 +67,11 @@ where
 }
 
 /// Runs cargo
-pub fn cargo<P>(commands: &[&str], target: Option<&str>, manifest_path: P) -> Result<(), CargoError>
+pub fn cargo<P>(
+    commands: &[&str],
+    target: Option<&str>,
+    manifest_path: P,
+) -> Result<(), ProcessError>
 where
     P: AsRef<std::path::Path>,
 {
@@ -73,7 +84,7 @@ pub fn cargo_with_env<P>(
     target: Option<&str>,
     manifest_path: P,
     environment: &[(&'static str, String)],
-) -> Result<(), CargoError>
+) -> Result<(), ProcessError>
 where
     P: AsRef<std::path::Path>,
 {
@@ -93,11 +104,45 @@ where
 
     println!("Running: {:?}", command_line);
 
-    let output = command_line.output().map_err(CargoError::SpawnError)?;
+    let output = command_line.output().map_err(ProcessError::SpawnError)?;
 
     if output.status.success() {
         Ok(())
     } else {
-        Err(CargoError::RunError(output.status))
+        Err(ProcessError::RunError(output.status))
+    }
+}
+
+/// Make a binary version of an ELF file
+pub fn make_bin<P>(path: P) -> Result<std::path::PathBuf, ProcessError>
+where
+    P: AsRef<std::path::Path>,
+{
+    let path = path.as_ref();
+    println!("Making binary of: {}", path.display());
+    let output = std::process::Command::new("rustc")
+        .arg("--print")
+        .arg("target-libdir")
+        .output()
+        .expect("Failed to run rustc --print target-libdir");
+    let sysroot = String::from_utf8(output.stdout).expect("sysroot path isn't UTF-8");
+    let sysroot: std::path::PathBuf = sysroot.trim().into();
+    let mut objcopy = sysroot.clone();
+    objcopy.pop();
+    objcopy.push("bin");
+    objcopy.push("llvm-objcopy");
+    let mut command_line = std::process::Command::new(objcopy);
+    command_line.args(["-O", "binary"]);
+    command_line.arg(path);
+    let output_file = path.with_extension("bin");
+    command_line.arg(&output_file);
+    println!("Running: {:?}", command_line);
+    let output = command_line.output().map_err(ProcessError::SpawnError)?;
+    if output.status.success() {
+        Ok(output_file)
+    } else {
+        Err(ProcessError::RunError(output.status))
     }
 }
+
+// End of file

nbuild/src/lib.rs

@@ -45,21 +45,21 @@ fn packages() -> Vec<nbuild::Package> {
         nbuild::Package {
             name: "nbuild",
             path: std::path::Path::new("./nbuild/Cargo.toml"),
-            output: std::path::Path::new("./nbuild/target/debug/nbuild{exe}"),
+            output_template: None,
             kind: nbuild::PackageKind::NBuild,
             testable: true,
         },
         nbuild::Package {
-            name: "flames utility",
+            name: "flames",
             path: std::path::Path::new("./utilities/flames/Cargo.toml"),
-            output: std::path::Path::new("./target/{target}/{profile}/flames"),
+            output_template: Some("./target/{target}/{profile}/flames"),
             kind: nbuild::PackageKind::Utility,
             testable: false,
         },
         nbuild::Package {
             name: "Neotron OS",
             path: std::path::Path::new("./neotron-os/Cargo.toml"),
-            output: std::path::Path::new("./target/{target}/{profile}/neotron-os"),
+            output_template: Some("./target/{target}/{profile}/neotron-os"),
             kind: nbuild::PackageKind::Os,
             testable: false,
         },
@@ -91,11 +91,16 @@ fn main() {
 
 /// Builds the utility and OS packages as binaries
 fn binary(packages: &[nbuild::Package], start_address: &str, target: &str) {
+    use chrono::{Datelike, Timelike};
+
     let mut is_error = false;
     let Ok(start_address) = nbuild::parse_int(start_address) else {
         eprintln!("{:?} was not a valid integer", start_address);
         std::process::exit(1);
     };
+
+    let mut romfs_entries = Vec::new();
+    // Build utilities
     for package in packages
         .iter()
         .filter(|p| p.kind == nbuild::PackageKind::Utility)
@@ -108,7 +113,57 @@ fn binary(packages: &[nbuild::Package], start_address: &str, target: &str) {
             eprintln!("Build of {} failed: {}", package.name, e);
             is_error = true;
         }
+        let package_output = package
+            .output(target, "release")
+            .expect("utilties should have an output");
+        let contents = match std::fs::read(&package_output) {
+            Ok(contents) => contents,
+            Err(e) => {
+                eprintln!("Reading of {} failed: {}", package_output, e);
+                continue;
+            }
+        };
+        let ctime = std::time::SystemTime::now();
+        let ctime = chrono::DateTime::<chrono::Utc>::from(ctime);
+        romfs_entries.push(neotron_romfs::Entry {
+            metadata: neotron_romfs::EntryMetadata {
+                file_name: package.name,
+                ctime: neotron_api::file::Time {
+                    year_since_1970: (ctime.year() - 1970) as u8,
+                    zero_indexed_month: ctime.month0() as u8,
+                    zero_indexed_day: ctime.day0() as u8,
+                    hours: ctime.hour() as u8,
+                    minutes: ctime.minute() as u8,
+                    seconds: ctime.second() as u8,
+                },
+                file_size: contents.len() as u32,
+            },
+            contents,
+        });
     }
+
+    // Build ROMFS
+    let mut buffer = Vec::new();
+    let _size = match neotron_romfs::RomFs::construct_into(&mut buffer, &romfs_entries) {
+        Ok(size) => size,
+        Err(e) => {
+            eprintln!("Making ROMFS failed: {:?}", e);
+            std::process::exit(1);
+        }
+    };
+    let mut romfs_path = std::path::PathBuf::new();
+    romfs_path.push(std::env::current_dir().expect("We have no CWD?"));
+    romfs_path.push("target");
+    romfs_path.push(target);
+    romfs_path.push("release");
+    romfs_path.push("romfs.bin");
+    if let Err(e) = std::fs::write(&romfs_path, &buffer) {
+        eprintln!("Writing ROMFS to {} failed: {:?}", romfs_path.display(), e);
+        std::process::exit(1);
+    }
+    println!("Built ROMFS at {}", romfs_path.display());
+
+    // Build OS
     for package in packages
         .iter()
         .filter(|p| p.kind == nbuild::PackageKind::Os)
@@ -117,10 +172,13 @@ fn binary(packages: &[nbuild::Package], start_address: &str, target: &str) {
             "Cross-compiling {}, using start address 0x{:08x} and target {:?}",
             package.name, start_address, target
         );
-        let environment = [(
-            "NEOTRON_OS_START_ADDRESS",
-            format!("0x{:08x}", start_address),
-        )];
+        let environment = [
+            (
+                "NEOTRON_OS_START_ADDRESS",
+                format!("0x{:08x}", start_address),
+            ),
+            ("ROMFS_PATH", romfs_path.to_string_lossy().to_string()),
+        ];
         if let Err(e) = nbuild::cargo_with_env(
             &["build", "--release"],
             Some(target),
@@ -130,6 +188,13 @@ fn binary(packages: &[nbuild::Package], start_address: &str, target: &str) {
             eprintln!("Build of {} failed: {}", package.name, e);
             is_error = true;
         }
+        let package_output = package
+            .output(target, "release")
+            .expect("PackageKind::Os should always have output");
+        if let Err(e) = nbuild::make_bin(&package_output) {
+            eprintln!("objcopy of {} failed: {}", package_output, e);
+            is_error = true;
+        }
     }
     if is_error {
         std::process::exit(1);

nbuild/src/main.rs

@@ -36,9 +36,10 @@ fn main() {
         println!("cargo::rustc-link-lib=dylib=msvcrt");
     }
 
-    if option_env!("ROMFS_PATH").is_some() {
+    if let Some(path) = option_env!("ROMFS_PATH") {
         println!("cargo::rustc-cfg=romfs_enabled=\"yes\"");
         println!("cargo::rerun-if-env-changed=ROMFS_PATH");
+        println!("cargo::rerun-if-changed={}", path);
     }
     println!("cargo::rustc-check-cfg=cfg(romfs_enabled, values(\"yes\"))");
 }