Implements open for direct dumping

src/direct.rs

@@ -0,0 +1,58 @@
+use crate::method::{OpenFlags, OwnedFd};
+use crate::DumpMethod;
+use core::ffi::{c_int, CStr};
+use core::num::NonZeroI32;
+use korbis::thread::Thread;
+use korbis::uio::UioSeg;
+use korbis::Kernel;
+
+/// Implementation of [`DumpMethod`] using internal kernel functions.
+///
+/// This method require a first dump from syscall method for required function addresses.
+pub struct DirectMethod<K> {
+    kernel: K,
+}
+
+impl<K> DirectMethod<K> {
+    pub fn new(kernel: K) -> Self {
+        Self { kernel }
+    }
+}
+
+impl<K: Kernel> DumpMethod for DirectMethod<K> {
+    fn open(
+        &self,
+        path: &CStr,
+        flags: OpenFlags,
+        mode: c_int,
+    ) -> Result<OwnedFd<Self>, NonZeroI32> {
+        let td = Thread::current();
+        let errno = unsafe {
+            self.kernel.kern_openat(
+                td,
+                -100,
+                path.as_ptr(),
+                UioSeg::Kernel,
+                flags.bits() as _,
+                mode,
+            )
+        };
+
+        match NonZeroI32::new(errno) {
+            Some(v) => Err(v),
+            None => Ok(unsafe { OwnedFd::new(self, (*td).ret(0).try_into().unwrap()) }),
+        }
+    }
+
+    fn write(&self, fd: c_int, buf: *const u8, len: usize) -> Result<usize, NonZeroI32> {
+        Ok(len)
+    }
+
+    fn fsync(&self, fd: c_int) -> Result<(), NonZeroI32> {
+        Ok(())
+    }
+
+    fn close(&self, fd: c_int) -> Result<(), NonZeroI32> {
+        Ok(())
+    }
+}

src/main.rs

@@ -10,6 +10,8 @@ use core::panic::PanicInfo;
 use korbis::Kernel;
 use x86_64::registers::model_specific::LStar;
 
+#[cfg(method = "direct")]
+mod direct;
 mod method;
 #[cfg(method = "syscall")]
 mod syscall;
@@ -73,6 +75,8 @@ pub extern "C" fn main(_: *const u8) {
     // Setup dumping method.
     #[cfg(method = "syscall")]
     let method = unsafe { crate::syscall::SyscallMethod::new(&kernel) };
+    #[cfg(method = "direct")]
+    let method = crate::direct::DirectMethod::new(kernel);
 
     // Create dump file.
     let out = match method.open(
@@ -108,17 +112,17 @@ pub extern "C" fn main(_: *const u8) {
             return;
         }
 
-        // Sync.
-        if method.fsync(fd).is_err() {
-            notify(
-                &method,
-                "Failed to synchronize changes to a /mnt/usb0/kernel.elf",
-            );
+        data = &data[written..];
+    }
 
-            return;
-        }
+    // Sync.
+    if method.fsync(out.as_raw_fd()).is_err() {
+        notify(
+            &method,
+            "Failed to synchronize changes to a /mnt/usb0/kernel.elf",
+        );
 
-        data = &data[written..];
+        return;
     }
 
     notify(&method, "Dump completed!");