load elf from vfs

Author: xor-bits

Cargo.lock

@@ -6,7 +6,7 @@ edition = "2021"
 
 [workspace]
 resolver = "2"
-members = ["crates/*"]
+members = ["crates/*", "userspace/cat"]
 
 [profile.release]
 debug = true

Cargo.toml

@@ -37,3 +37,4 @@ hyperion-cpu-id.path = "../cpu-id"
 hyperion-kernel-impl.path = "../kernel-impl"
 
 hyperion-sample-elf = { path = "../sample-elf", artifact = "bin", target = "x86_64-unknown-none" }
+cat = { path = "../../userspace/cat", artifact = "bin", target = "x86_64-unknown-none" }

crates/kshell/Cargo.toml

@@ -11,8 +11,9 @@ use futures_util::StreamExt;
 use hyperion_color::Color;
 use hyperion_framebuffer::framebuffer::Framebuffer;
 use hyperion_futures::{keyboard::KeyboardEvents, timer::ticks};
+use hyperion_kernel_impl::VFS_ROOT;
 use hyperion_random::Rng;
-use hyperion_vfs::{error::IoError, path::PathBuf};
+use hyperion_vfs::{error::IoError, path::PathBuf, ramdisk};
 use snafu::Snafu;
 use time::Duration;
 
@@ -29,6 +30,11 @@ pub mod term;
 pub async fn kshell() {
     hyperion_futures::executor::spawn(spinner());
 
+    let bin = include_bytes!(env!("CARGO_BIN_FILE_HYPERION_SAMPLE_ELF"));
+    VFS_ROOT.install_dev("/bin/run", ramdisk::File::new(bin.into()));
+    let bin = include_bytes!(env!("CARGO_BIN_FILE_CAT"));
+    VFS_ROOT.install_dev("/bin/cat", ramdisk::File::new(bin.into()));
+
     let term = Term::new();
     let mut shell = Shell::new(term);
 

crates/kshell/src/lib.rs

@@ -143,7 +143,7 @@ impl Shell {
             "pwd" => self.pwd_cmd(args)?,
             "cd" => self.cd_cmd(args)?,
             "ls" => self.ls_cmd(args)?,
-            "cat" => self.cat_cmd(args)?,
+            // "cat" => self.cat_cmd(args)?,
             "date" => self.date_cmd(args)?,
             "mem" => self.mem_cmd(args)?,
             "sleep" => self.sleep_cmd(args).await?,
@@ -154,7 +154,7 @@ impl Shell {
             "snake" => self.snake_cmd(args).await?,
             "help" => self.help_cmd(args)?,
             "modeltest" => self.modeltest_cmd(args).await?,
-            "run" => self.run_cmd(args).await?,
+            // "run" => self.run_cmd(args).await?,
             "lapic_id" => self.lapic_id_cmd(args)?,
             "cpu_id" => self.cpu_id_cmd(args)?,
             "ps" => self.ps_cmd(args)?,
@@ -168,8 +168,30 @@ impl Shell {
             }
             "" => self.term.write_byte(b'\n'),
             other => {
-                _ = writeln!(self.term, "unknown command {other}");
-                self.help_cmd(None)?;
+                let path = format!("/bin/{other}");
+                let Ok(bin) = VFS_ROOT.find_file(path.as_str(), false, false) else {
+                    _ = writeln!(self.term, "unknown command {other}");
+                    self.help_cmd(None)?;
+                    return Ok(Some(()));
+                };
+
+                let bin = bin.lock();
+
+                let mut elf = Vec::new();
+
+                loop {
+                    let mut buf = [0; 64];
+                    let len = bin.read(elf.len(), &mut buf).unwrap();
+                    elf.extend_from_slice(&buf[..len]);
+                    if len == 0 {
+                        break;
+                    }
+                }
+
+                drop(bin);
+
+                self.run_cmd_from(path.into(), Cow::Owned(elf), args)
+                    .await?;
             }
         }
 
@@ -527,7 +549,17 @@ impl Shell {
     }
 
     async fn run_cmd(&mut self, args: Option<&str>) -> Result<()> {
-        let name = "/bin/run";
+        let elf_bytes = include_bytes!(env!("CARGO_BIN_FILE_HYPERION_SAMPLE_ELF"));
+        self.run_cmd_from("/bin/run".into(), Cow::Borrowed(elf_bytes), args)
+            .await
+    }
+
+    async fn run_cmd_from(
+        &mut self,
+        name: Cow<'static, str>,
+        elf: Cow<'static, [u8]>,
+        args: Option<&str>,
+    ) -> Result<()> {
         let args = args.map(String::from);
 
         // let stdin_tx = pipe();
@@ -559,6 +591,7 @@ impl Shell {
         });
 
         let pid = schedule(move || {
+            let name = name.as_ref();
             hyperion_scheduler::rename(name);
 
             hyperion_kernel_impl::push_file(hyperion_kernel_impl::FileInner {
@@ -588,16 +621,14 @@ impl Shell {
                 "ELF file from: {}",
                 env!("CARGO_BIN_FILE_HYPERION_SAMPLE_ELF")
             );
-            let elf_bytes = include_bytes!(env!("CARGO_BIN_FILE_HYPERION_SAMPLE_ELF"));
-            let loader = hyperion_loader::Loader::new(elf_bytes);
+            let loader = hyperion_loader::Loader::new(elf.as_ref());
 
             loader.load();
 
             if loader.enter_userland(args).is_none() {
                 hyperion_log::debug!("entry point missing");
             }
         });
-        hyperion_log::trace!("spawning {name} done (PID:{pid})");
 
         let mut events = select(KeyboardEvents.map(Ok), o_rx.race_stream().map(Err));
 

crates/kshell/src/shell.rs

@@ -103,3 +103,21 @@ impl FileDevice for [u8] {
         Ok(len)
     }
 }
+
+impl<T: FileDevice> FileDevice for &'static T {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn len(&self) -> usize {
+        (**self).len()
+    }
+
+    fn read(&self, offset: usize, buf: &mut [u8]) -> IoResult<usize> {
+        (**self).read(offset, buf)
+    }
+
+    fn write(&mut self, _: usize, _: &[u8]) -> IoResult<usize> {
+        Err(IoError::PermissionDenied)
+    }
+}

crates/vfs/src/device.rs

@@ -19,6 +19,12 @@ pub struct File {
     bytes: Vec<u8>,
 }
 
+impl File {
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Self { bytes }
+    }
+}
+
 pub struct Directory<Mut: AnyMutex> {
     pub name: Arc<str>,
     pub children: BTreeMap<Arc<str>, Node<Mut>>,

crates/vfs/src/ramdisk.rs

@@ -0,0 +1,9 @@
+[package]
+name = "cat"
+version.workspace = true
+edition.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+libstd.path = "../../crates/libstd"

userspace/cat/Cargo.toml

@@ -0,0 +1,3 @@
+fn main() {
+    println!("cargo:rustc-link-arg=-no-pie");
+}

userspace/cat/build.rs

@@ -0,0 +1,14 @@
+#![no_std]
+#![no_main]
+#![feature(format_args_nl)]
+
+//
+
+use libstd::println;
+
+//
+
+#[no_mangle]
+fn main() {
+    println!("Hello, world!");
+}