use { derive_more::{Deref, DerefMut, Display}, error_stack::{bail, ensure, report, Context, IntoReport, Result, ResultExt}, fatfs::{FileSystem, FormatVolumeOptions, FsOptions, ReadWriteSeek}, std::{ fmt::Display, fs::File, io::{self, Write}, path::Path, process::Command, }, }; fn main() -> Result<(), Error> { env_logger::init(); let mut args = std::env::args(); args.next(); // let disk_meta = fs::metadata("target/disk.img").unwrap(); // let config_meta = fs::metadata("system.toml").unwrap(); // if disk_meta.modified().unwrap() < config_meta.modified().unwrap() { // // TODO: work on adding in system.toml support // // TODO: rebuild the disk // } match args.next().as_deref() { Some("build" | "b") => { let mut release = false; let mut target = Target::X86_64; for arg in args { if arg == "-r" || arg == "--release" { release = true; } if arg == "rv64" || arg == "riscv64" || arg == "riscv64-virt" { target = Target::Riscv64Virt; } if arg == "aarch" || arg == "arm64" { target = Target::Aarch64; } } build(release, target).change_context(Error::Build) } Some("run" | "r") => { let mut release = false; let mut target = Target::X86_64; for arg in args { if arg == "-r" || arg == "--release" { release = true; } if arg == "rv64" || arg == "riscv64" || arg == "riscv64-virt" { target = Target::Riscv64Virt; } if arg == "arm64" || arg == "aarch64" { target = Target::Aarch64; } } build(release, target)?; run(release, target) } Some("help" | "h") => { println!(concat!( "AbleOS RepBuild\n", "Subcommands:\n", " build (b): Build a bootable disk image\n", " help (h): Print this message\n", " run (r): Build and run AbleOS in QEMU\n\n", "Options for build and run:\n", " -r: build in release mode", " [target]: sets target" ),); Ok(()) } _ => Err(report!(Error::InvalidSubCom)), } } fn get_fs() -> Result, io::Error> { let path = Path::new("target/disk.img"); match std::fs::metadata(path) { Err(e) if e.kind() == io::ErrorKind::NotFound => (), Err(e) => bail!(e), Ok(_) => { return FileSystem::new( File::options().read(true).write(true).open(path)?, FsOptions::new(), ) .into_report() } } let mut img = File::options() .read(true) .write(true) .create(true) .open(path)?; img.set_len(1024 * 1024 * 64)?; fatfs::format_volume(&mut img, FormatVolumeOptions::new())?; let fs = FileSystem::new(img, FsOptions::new())?; let bootdir = fs.root_dir().create_dir("efi")?.create_dir("boot")?; io::copy( &mut File::open("limine/BOOTX64.EFI") .into_report() .attach_printable("copying Limine bootloader (have you pulled the submodule?)")?, &mut bootdir.create_file("bootx64.efi")?, )?; io::copy( &mut File::open("repbuild/limine.cfg")?, &mut fs.root_dir().create_file("limine.cfg")?, )?; io::copy( &mut File::open("repbuild/background.bmp")?, &mut fs.root_dir().create_file("background.bmp")?, )?; io::copy( &mut File::open("repbuild/inf_loop.hb")?, &mut fs.root_dir().create_file("inf_loop.hb")?, )?; drop(bootdir); Ok(fs) } fn build(release: bool, target: Target) -> Result<(), Error> { fetch_ovmf().change_context(Error::OvmfFetch)?; let fs = get_fs().change_context(Error::Io)?; let mut com = Command::new("cargo"); com.current_dir("kernel"); com.args(["b"]); if release { com.arg("-r"); } if target == Target::Riscv64Virt { com.args(["--target", "targets/riscv64-virt-ableos.json"]); } if target == Target::Aarch64 { com.args(["--target", "targets/aarch64-virt-ableos.json"]); } match com.status() { Ok(s) if s.code() != Some(0) => bail!(Error::Build), Err(e) => bail!(report!(e).change_context(Error::Build)), _ => (), } if target != Target::X86_64 { return Ok(()); } (|| -> std::io::Result<_> { io::copy( &mut File::open( Path::new("target/x86_64-ableos") .join(if release { "release" } else { "debug" }) .join("kernel"), )?, &mut fs.root_dir().create_file("kernel")?, ) .map(|_| ()) })() .into_report() .change_context(Error::Io) } fn run(release: bool, target: Target) -> Result<(), Error> { let mut com = match target { Target::X86_64 => Command::new("qemu-system-x86_64"), Target::Riscv64Virt => Command::new("qemu-system-riscv64"), Target::Aarch64 => Command::new("qemu-system-aarch64"), }; if target == Target::X86_64 { #[rustfmt::skip] com.args([ "-bios", "target/OVMF_CODE.fd", "-drive", "file=target/disk.img,format=raw", "-m", "4G", // "-serial", "stdio", "-smp", "cores=4", // "-vga", "cirrus", // "-device", "ati-vga", // "-device", "virtio-gpu-pci", // "-device", "virtio-serial,id=virtio-serial0", // "-chardev", "stdio,id=char0,mux=on", // "-device", "virtconsole,chardev=char0", // "-device", "virtio-mouse-pci", // "-device", "ati-vga", "model=rage128p" ]); #[cfg(target_os = "linux")] { //com.args(["-enable-kvm", "-cpu", "host"]); } } if target == Target::Riscv64Virt { #[rustfmt::skip] com.args([ "-M", "virt", "-m", "128M", "-serial", "stdio", "-kernel", if release { "target/riscv64-virt-ableos/release/kernel" } else { "target/riscv64-virt-ableos/debug/kernel" } ]); } if target == Target::Aarch64 { com.args([ "-M", "virt", "-m", // "128M", // "-serial", "stdio", ]); } match com .status() .into_report() .change_context(Error::ProcessSpawn)? { s if s.success() => Ok(()), s => Err(report!(Error::Qemu(s.code()))), } } fn fetch_ovmf() -> Result<(), OvmfFetchError> { const OVMF_RPM_URL: &str = "https://kojipkgs.fedoraproject.org/packages/edk2/20230524/3.fc38/noarch/edk2-ovmf-20230524-3.fc38.noarch.rpm"; let mut file = match std::fs::metadata("target/OVMF_CODE.fd") { Err(e) if e.kind() == std::io::ErrorKind::NotFound => std::fs::OpenOptions::new() .create(true) .write(true) .read(true) .open("target/OVMF_CODE.fd") .into_report() .change_context(OvmfFetchError::Io)?, Ok(_) => return Ok(()), Err(e) => return Err(report!(e).change_context(OvmfFetchError::Io)), }; log::info!("No OVMF found, downloading…"); let rpm = rpm::RPMPackage::parse( &mut std::convert::identity::>((|| { reqwest::blocking::get(OVMF_RPM_URL)?.bytes() })()) .into_report() .change_context(OvmfFetchError::Fetch)? .as_ref(), ) .map_err(RpmError) .into_report() .change_context(OvmfFetchError::RpmParse)?; ensure!( rpm.metadata .get_payload_compressor() .map_err(RpmError) .into_report() .change_context(OvmfFetchError::RpmParse)? == rpm::CompressionType::Zstd, OvmfFetchError::UnsupportedCompression, ); file.write_all( cpio_reader::iter_files( &zstd::decode_all(std::io::Cursor::new(rpm.content)) .into_report() .change_context(OvmfFetchError::Zstd)?, ) .find(|file| file.name() == "./usr/share/edk2/ovmf/OVMF_CODE.fd") .ok_or_else(|| report!(OvmfFetchError::NoFileFound))? .file(), ) .into_report() .change_context(OvmfFetchError::Io)?; Ok(()) } #[derive(Debug, Display, Deref, DerefMut)] struct RpmError(rpm::RPMError); impl Context for RpmError {} // Ehhh?? I am pretty sure they just forgot :ferrisClueless: unsafe impl Sync for RpmError {} unsafe impl Send for RpmError {} #[derive(Debug, Display)] enum OvmfFetchError { #[display(fmt = "Failed to fetch OVMF package")] Fetch, #[display(fmt = "RPM parse error")] RpmParse, #[display(fmt = "Unsupported compression (ZSTD is the only supported one)")] UnsupportedCompression, #[display(fmt = "Decompression error")] Zstd, #[display(fmt = "Requested file not found in package")] NoFileFound, #[display(fmt = "IO Error")] Io, } impl Context for OvmfFetchError {} #[derive(Clone, Copy, PartialEq, Eq)] enum Target { X86_64, Riscv64Virt, Aarch64, } #[derive(Debug, Display)] enum Error { #[display(fmt = "Failed to build the kernel")] Build, #[display(fmt = "Missing or invalid subcommand (available: build, run)")] InvalidSubCom, #[display(fmt = "IO Error")] Io, #[display(fmt = "Failed to spawn a process")] ProcessSpawn, #[display(fmt = "Failed to fetch UEFI firmware")] OvmfFetch, #[display(fmt = "QEMU Error: {}", "fmt_qemu_err(*_0)")] Qemu(Option), } impl Context for Error {} fn fmt_qemu_err(e: Option) -> impl Display { struct W(Option); impl Display for W { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { if let Some(c) = self.0 { c.fmt(f) } else { f.write_str("Interrupted by signal") } } } W(e) }