add read/write address and text section offset support

Signed-off-by: Doru Blânzeanu <[email protected]>

Author: dblnz

src/hyperlight_host/src/hypervisor/gdb/event_loop.rs

@@ -81,7 +81,7 @@ pub fn event_loop_thread(
 ) {
     match debugger.run_blocking::<GdbBlockingEventLoop>(target) {
         Ok(disconnect_reason) => match disconnect_reason {
-            DisconnectReason::Disconnect => { 
+            DisconnectReason::Disconnect => {
                 log::info!("Gdb client disconnected");
                 if let Err(e) = target.disable_debug() {
                     log::error!("Cannot disable debugging: {:?}", e);

src/hyperlight_host/src/hypervisor/gdb/mod.rs

@@ -86,9 +86,12 @@ pub enum DebugMsg {
     AddHwBreakpoint(u64),
     Continue,
     DisableDebug,
+    GetCodeSectionOffset,
+    ReadAddr(u64, usize),
     ReadRegisters,
     RemoveHwBreakpoint(u64),
     Step,
+    WriteAddr(u64, Vec<u8>),
     WriteRegisters(X86_64Regs),
 }
 
@@ -98,10 +101,13 @@ pub enum DebugResponse {
     AddHwBreakpoint(bool),
     Continue,
     DisableDebug,
+    GetCodeSectionOffset(u64),
+    ReadAddr(Vec<u8>),
     ReadRegisters(X86_64Regs),
     RemoveHwBreakpoint(bool),
     Step,
     VcpuStopped(VcpuStopReason),
+    WriteAddr,
     WriteRegisters,
 }
 

src/hyperlight_host/src/hypervisor/gdb/x86_64_target.rs

@@ -9,10 +9,11 @@ use gdbstub::target::ext::base::BaseOps;
 use gdbstub::target::ext::breakpoints::{
     Breakpoints, BreakpointsOps, HwBreakpoint, HwBreakpointOps,
 };
+use gdbstub::target::ext::section_offsets::{Offsets, SectionOffsets};
 use gdbstub::target::{Target, TargetError, TargetResult};
 use gdbstub_arch::x86::X86_64_SSE as GdbTargetArch;
 
-use super::{DebugMsg, DebugResponse, DebugCommChannel, GdbTargetError, X86_64Regs};
+use super::{DebugCommChannel, DebugMsg, DebugResponse, GdbTargetError, X86_64Regs};
 
 /// Gdbstub target used by the gdbstub crate to provide GDB protocol implementation
 pub struct HyperlightSandboxTarget {
@@ -90,6 +91,12 @@ impl Target for HyperlightSandboxTarget {
     fn base_ops(&mut self) -> BaseOps<Self::Arch, Self::Error> {
         BaseOps::SingleThread(self)
     }
+
+    fn support_section_offsets(
+        &mut self,
+    ) -> Option<gdbstub::target::ext::section_offsets::SectionOffsetsOps<Self>> {
+        Some(self)
+    }
 }
 
 impl SingleThreadBase for HyperlightSandboxTarget {
@@ -100,7 +107,17 @@ impl SingleThreadBase for HyperlightSandboxTarget {
     ) -> TargetResult<usize, Self> {
         log::debug!("Read addr: {:X} len: {:X}", gva, data.len());
 
-        unimplemented!()
+        match self.send_command(DebugMsg::ReadAddr(gva, data.len()))? {
+            DebugResponse::ReadAddr(v) => {
+                data.copy_from_slice(&v);
+
+                Ok(v.len())
+            }
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
+            }
+        }
     }
 
     fn write_addrs(
@@ -109,8 +126,15 @@ impl SingleThreadBase for HyperlightSandboxTarget {
         data: &[u8],
     ) -> TargetResult<(), Self> {
         log::debug!("Write addr: {:X} len: {:X}", gva, data.len());
+        let v = Vec::from(data);
 
-        unimplemented!()
+        match self.send_command(DebugMsg::WriteAddr(gva, v))? {
+            DebugResponse::WriteAddr => Ok(()),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(TargetError::Fatal(GdbTargetError::UnexpectedMessage))
+            }
+        }
     }
 
     fn read_registers(
@@ -191,6 +215,22 @@ impl SingleThreadBase for HyperlightSandboxTarget {
         Some(self)
     }
 }
+impl SectionOffsets for HyperlightSandboxTarget {
+    fn get_section_offsets(&mut self) -> Result<Offsets<<Self::Arch as Arch>::Usize>, Self::Error> {
+        log::debug!("Get section offsets");
+
+        match self.send_command(DebugMsg::GetCodeSectionOffset)? {
+            DebugResponse::GetCodeSectionOffset(text) => Ok(Offsets::Segments {
+                text_seg: text,
+                data_seg: None,
+            }),
+            msg => {
+                log::error!("Unexpected message received: {:?}", msg);
+                Err(GdbTargetError::UnexpectedMessage)
+            }
+        }
+    }
+}
 
 impl Breakpoints for HyperlightSandboxTarget {
     fn support_hw_breakpoint(&mut self) -> Option<HwBreakpointOps<Self>> {

src/hyperlight_host/src/hypervisor/kvm.rs

@@ -66,6 +66,8 @@ pub(crate) fn is_hypervisor_present() -> bool {
 #[cfg(gdb)]
 mod debug {
     use std::sync::{Arc, Mutex};
+
+    use hyperlight_common::mem::PAGE_SIZE;
     use kvm_bindings::{
         kvm_guest_debug, kvm_regs, KVM_GUESTDBG_ENABLE, KVM_GUESTDBG_SINGLESTEP,
         KVM_GUESTDBG_USE_HW_BP, KVM_GUESTDBG_USE_SW_BP,
@@ -75,6 +77,7 @@ mod debug {
     use super::KVMDriver;
     use crate::hypervisor::gdb::{DebugMsg, DebugResponse, VcpuStopReason, X86_64Regs};
     use crate::hypervisor::handlers::DbgMemAccessHandlerCaller;
+    use crate::mem::layout::SandboxMemoryLayout;
     use crate::{new_error, Result};
 
     /// KVM Debug struct
@@ -212,6 +215,70 @@ mod debug {
             }
         }
 
+        pub fn read_addrs(
+            &mut self,
+            mut gva: u64,
+            mut data: &mut [u8],
+            dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
+        ) -> Result<()> {
+            let data_len = data.len();
+            log::debug!("Read addr: {:X} len: {:X}", gva, data_len);
+
+            while !data.is_empty() {
+                let gpa = self.translate_gva(gva)?;
+
+                let read_len = std::cmp::min(
+                    data.len(),
+                    (PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
+                );
+                let offset = gpa as usize - SandboxMemoryLayout::BASE_ADDRESS;
+
+                dbg_mem_access_fn
+                    .clone()
+                    .try_lock()
+                    .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
+                    .read(offset, &mut data[..read_len])?;
+
+                data = &mut data[read_len..];
+                gva += read_len as u64;
+            }
+
+            log::debug!("data before after {:?}", data);
+
+            Ok(())
+        }
+
+        pub fn write_addrs(
+            &mut self,
+            mut gva: u64,
+            mut data: &[u8],
+            dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
+        ) -> Result<()> {
+            let data_len = data.len();
+            log::debug!("Write addr: {:X} len: {:X}", gva, data_len);
+
+            while !data.is_empty() {
+                let gpa = self.translate_gva(gva)?;
+
+                let write_len = std::cmp::min(
+                    data.len(),
+                    (PAGE_SIZE - (gpa & (PAGE_SIZE - 1))).try_into().unwrap(),
+                );
+                let offset = gpa as usize - SandboxMemoryLayout::BASE_ADDRESS;
+
+                dbg_mem_access_fn
+                    .clone()
+                    .try_lock()
+                    .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
+                    .write(offset, data)?;
+
+                data = &data[write_len..];
+                gva += write_len as u64;
+            }
+
+            Ok(())
+        }
+
         pub fn read_regs(&self, regs: &mut X86_64Regs) -> Result<()> {
             log::debug!("Read registers");
             let vcpu_regs = self
@@ -342,7 +409,7 @@ mod debug {
         pub fn process_dbg_request(
             &mut self,
             req: DebugMsg,
-            _dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
+            dbg_mem_access_fn: Arc<Mutex<dyn DbgMemAccessHandlerCaller>>,
         ) -> Result<DebugResponse> {
             match req {
                 DebugMsg::AddHwBreakpoint(addr) => {
@@ -360,6 +427,22 @@ mod debug {
 
                     Ok(DebugResponse::DisableDebug)
                 }
+                DebugMsg::GetCodeSectionOffset => {
+                    let offset = dbg_mem_access_fn
+                        .clone()
+                        .try_lock()
+                        .map_err(|e| new_error!("Error locking at {}:{}: {}", file!(), line!(), e))?
+                        .get_code_offset()?;
+
+                    Ok(DebugResponse::GetCodeSectionOffset(offset as u64))
+                }
+                DebugMsg::ReadAddr(addr, len) => {
+                    let mut data = vec![0u8; len];
+
+                    self.read_addrs(addr, &mut data, dbg_mem_access_fn.clone())?;
+
+                    Ok(DebugResponse::ReadAddr(data))
+                }
                 DebugMsg::ReadRegisters => {
                     let mut regs = X86_64Regs::default();
                     self.read_regs(&mut regs).expect("Read Regs error");
@@ -375,6 +458,11 @@ mod debug {
                     self.set_single_step(true)?;
                     Ok(DebugResponse::Step)
                 }
+                DebugMsg::WriteAddr(addr, data) => {
+                    self.write_addrs(addr, &data, dbg_mem_access_fn.clone())?;
+
+                    Ok(DebugResponse::WriteAddr)
+                }
                 DebugMsg::WriteRegisters(regs) => {
                     self.write_regs(&regs).expect("Write Regs error");
                     Ok(DebugResponse::WriteRegisters)