more debugging of page table issues

xencall/src/domctl.rs

@@ -1,9 +1,10 @@
 use crate::sys::{
     AddressSize, ArchDomainConfig, CreateDomain, DomCtl, DomCtlValue, DomCtlVcpuContext,
-    GetDomainInfo, HypercallInit, MaxMem, MaxVcpus, VcpuGuestContext, VcpuGuestContextAny,
-    HYPERVISOR_DOMCTL, XEN_DOMCTL_CREATEDOMAIN, XEN_DOMCTL_DESTROYDOMAIN, XEN_DOMCTL_GETDOMAININFO,
-    XEN_DOMCTL_GETVCPUCONTEXT, XEN_DOMCTL_HYPERCALL_INIT, XEN_DOMCTL_INTERFACE_VERSION,
-    XEN_DOMCTL_MAX_MEM, XEN_DOMCTL_MAX_VCPUS, XEN_DOMCTL_PAUSEDOMAIN, XEN_DOMCTL_SETVCPUCONTEXT,
+    GetDomainInfo, GetPageFrameInfo3, HypercallInit, MaxMem, MaxVcpus, VcpuGuestContext,
+    VcpuGuestContextAny, HYPERVISOR_DOMCTL, XEN_DOMCTL_CREATEDOMAIN, XEN_DOMCTL_DESTROYDOMAIN,
+    XEN_DOMCTL_GETDOMAININFO, XEN_DOMCTL_GETPAGEFRAMEINFO3, XEN_DOMCTL_GETVCPUCONTEXT,
+    XEN_DOMCTL_HYPERCALL_INIT, XEN_DOMCTL_INTERFACE_VERSION, XEN_DOMCTL_MAX_MEM,
+    XEN_DOMCTL_MAX_VCPUS, XEN_DOMCTL_PAUSEDOMAIN, XEN_DOMCTL_SETVCPUCONTEXT,
     XEN_DOMCTL_SET_ADDRESS_SIZE,
 };
 use crate::{XenCall, XenCallError};
@@ -11,6 +12,7 @@ use log::trace;
 use std::ffi::c_ulong;
 use std::os::fd::AsRawFd;
 use std::ptr::addr_of_mut;
+use std::slice;
 
 pub struct DomainControl<'a> {
     call: &'a XenCall,
@@ -214,6 +216,34 @@ impl DomainControl<'_> {
         Ok(())
     }
 
+    pub fn get_page_frame_info(
+        &self,
+        domid: u32,
+        frames: &[u64],
+    ) -> Result<Vec<u64>, XenCallError> {
+        let mut buffer: Vec<u64> = frames.to_vec();
+        let mut domctl = DomCtl {
+            cmd: XEN_DOMCTL_GETPAGEFRAMEINFO3,
+            interface_version: XEN_DOMCTL_INTERFACE_VERSION,
+            domid,
+            value: DomCtlValue {
+                get_page_frame_info: GetPageFrameInfo3 {
+                    num: buffer.len() as u64,
+                    array: buffer.as_mut_ptr() as c_ulong,
+                },
+            },
+        };
+        self.call
+            .hypercall1(HYPERVISOR_DOMCTL, addr_of_mut!(domctl) as c_ulong)?;
+        let slice = unsafe {
+            slice::from_raw_parts_mut(
+                domctl.value.get_page_frame_info.array as *mut u64,
+                domctl.value.get_page_frame_info.num as usize,
+            )
+        };
+        Ok(slice.to_vec())
+    }
+
     pub fn hypercall_init(&self, domid: u32, gmfn: u64) -> Result<(), XenCallError> {
         trace!(
             "domctl fd={} hypercall_init domid={} gmfn={}",

xencall/src/memory.rs

@@ -1,10 +1,11 @@
 use crate::sys::{
-    MemoryReservation, MultiCallEntry, HYPERVISOR_MEMORY_OP, XEN_MEM_POPULATE_PHYSMAP,
+    MemoryMap, MemoryReservation, MmuExtOp, MultiCallEntry, HYPERVISOR_MEMORY_OP,
+    HYPERVISOR_MMUEXT_OP, XEN_MEM_MEMORY_MAP, XEN_MEM_POPULATE_PHYSMAP,
 };
 use crate::{XenCall, XenCallError};
 
 use log::trace;
-use std::ffi::c_ulong;
+use std::ffi::{c_uint, c_ulong};
 use std::os::fd::AsRawFd;
 use std::ptr::addr_of_mut;
 
@@ -17,6 +18,26 @@ impl MemoryControl<'_> {
         MemoryControl { call }
     }
 
+    pub fn get_memory_map(&self, size_of_entry: usize) -> Result<Vec<u8>, XenCallError> {
+        let mut memory_map = MemoryMap {
+            count: 0,
+            buffer: 0,
+        };
+        self.call.hypercall2(
+            HYPERVISOR_MEMORY_OP,
+            XEN_MEM_MEMORY_MAP as c_ulong,
+            addr_of_mut!(memory_map) as c_ulong,
+        )?;
+        let mut buffer = vec![0u8; memory_map.count as usize * size_of_entry];
+        memory_map.buffer = buffer.as_mut_ptr() as c_ulong;
+        self.call.hypercall2(
+            HYPERVISOR_MEMORY_OP,
+            XEN_MEM_MEMORY_MAP as c_ulong,
+            addr_of_mut!(memory_map) as c_ulong,
+        )?;
+        Ok(buffer)
+    }
+
     pub fn populate_physmap(
         &self,
         domid: u32,
@@ -62,4 +83,24 @@ impl MemoryControl<'_> {
         let extents = extent_starts[0..code as usize].to_vec();
         Ok(extents)
     }
+
+    pub fn mmuext(
+        &self,
+        domid: u32,
+        cmd: c_uint,
+        arg1: u64,
+        arg2: u64,
+    ) -> Result<(), XenCallError> {
+        let mut ops = MmuExtOp { cmd, arg1, arg2 };
+
+        self.call
+            .hypercall4(
+                HYPERVISOR_MMUEXT_OP,
+                addr_of_mut!(ops) as c_ulong,
+                1,
+                0,
+                domid as c_ulong,
+            )
+            .map(|_| ())
+    }
 }

xencall/src/sys.rs

@@ -223,6 +223,7 @@ pub union DomCtlValue {
     pub hypercall_init: HypercallInit,
     pub vcpu_context: DomCtlVcpuContext,
     pub address_size: AddressSize,
+    pub get_page_frame_info: GetPageFrameInfo3,
     pub pad: [u8; 128],
 }
 
@@ -287,6 +288,13 @@ pub struct GetDomainInfo {
     pub arch: ArchDomainConfig,
 }
 
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct GetPageFrameInfo3 {
+    pub num: u64,
+    pub array: c_ulong,
+}
+
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
 pub struct ArchDomainConfig {
@@ -342,6 +350,14 @@ pub struct MultiCallEntry {
 }
 
 pub const XEN_MEM_POPULATE_PHYSMAP: u32 = 6;
+pub const XEN_MEM_MEMORY_MAP: u32 = 9;
+
+#[repr(C)]
+#[derive(Copy, Clone, Debug)]
+pub struct MemoryMap {
+    pub count: c_uint,
+    pub buffer: c_ulong,
+}
 
 #[repr(C)]
 #[derive(Copy, Clone, Debug)]
@@ -456,3 +472,13 @@ impl Default for VcpuGuestContext {
 pub union VcpuGuestContextAny {
     pub value: VcpuGuestContext,
 }
+
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct MmuExtOp {
+    pub cmd: c_uint,
+    pub arg1: c_ulong,
+    pub arg2: c_ulong,
+}
+
+pub const MMUEXT_PIN_L4_TABLE: u32 = 3;