chore(xen): move device creation into transaction interface (#196)

* chore(xen): move domain creation to xenplatform

* chore(xen): move device transactions into separate interface

crates/xen/xenplatform/src/boot.rs

@@ -43,7 +43,8 @@ pub struct BootDomain {
     pub store_evtchn: u32,
     pub store_mfn: u64,
     pub initrd_segment: DomainSegment,
-    pub consoles: Vec<(u32, u64)>,
+    pub console_evtchn: u32,
+    pub console_mfn: u64,
     pub cmdline: String,
 }
 
@@ -177,7 +178,8 @@ impl<I: BootImageLoader, P: BootSetupPlatform> BootSetup<I, P> {
             target_pages: total_pages,
             page_size: self.platform.page_size(),
             image_info,
-            consoles: Vec::new(),
+            console_evtchn: 0,
+            console_mfn: 0,
             max_vcpus,
             phys: PhysicalPages::new(self.call.clone(), self.domid, self.platform.page_shift()),
             initrd_segment: DomainSegment::default(),
@@ -261,7 +263,7 @@ impl<I: BootImageLoader, P: BootSetupPlatform> BootSetup<I, P> {
 
 #[async_trait::async_trait]
 pub trait BootSetupPlatform: Clone {
-    fn create_domain(&self, needs_passthrough: bool) -> CreateDomain;
+    fn create_domain(&self, enable_iommu: bool) -> CreateDomain;
     fn page_size(&self) -> u64;
     fn page_shift(&self) -> u64;
     fn needs_early_kernel(&self) -> bool;

crates/xen/xenplatform/src/domain.rs

@@ -0,0 +1,80 @@
+use std::sync::Arc;
+
+use crate::{
+    boot::{BootSetup, BootSetupPlatform},
+    elfloader::ElfImageLoader,
+};
+use uuid::Uuid;
+use xencall::XenCall;
+
+use crate::error::Result;
+
+pub struct BaseDomainManager<P: BootSetupPlatform> {
+    call: XenCall,
+    pub platform: Arc<P>,
+}
+
+impl<P: BootSetupPlatform> BaseDomainManager<P> {
+    pub async fn new(call: XenCall, platform: P) -> Result<BaseDomainManager<P>> {
+        Ok(BaseDomainManager {
+            call,
+            platform: Arc::new(platform),
+        })
+    }
+
+    pub async fn create(&self, config: BaseDomainConfig) -> Result<CreatedDomain> {
+        let mut domain = self.platform.create_domain(config.enable_iommu);
+        domain.handle = config.uuid.into_bytes();
+        domain.max_vcpus = config.max_vcpus;
+        let domid = self.call.create_domain(domain).await?;
+        self.call.set_max_vcpus(domid, config.max_vcpus).await?;
+        self.call
+            .set_max_mem(domid, (config.mem_mb * 1024) + 2048)
+            .await?;
+        let loader = ElfImageLoader::load_file_kernel(&config.kernel)?;
+        let platform = (*self.platform).clone();
+        let mut boot = BootSetup::new(self.call.clone(), domid, platform, loader, None);
+        let mut domain = boot
+            .initialize(
+                &config.initrd,
+                config.mem_mb,
+                config.max_vcpus,
+                &config.cmdline,
+            )
+            .await?;
+        boot.boot(&mut domain).await?;
+        Ok(CreatedDomain {
+            domid,
+            store_evtchn: domain.store_evtchn,
+            store_mfn: domain.store_mfn,
+            console_evtchn: domain.console_evtchn,
+            console_mfn: domain.console_mfn,
+        })
+    }
+
+    pub async fn destroy(&self, domid: u32) -> Result<()> {
+        self.call.destroy_domain(domid).await?;
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct BaseDomainConfig {
+    pub uuid: Uuid,
+    pub owner_domid: u32,
+    pub max_vcpus: u32,
+    pub mem_mb: u64,
+    pub kernel: Vec<u8>,
+    pub initrd: Vec<u8>,
+    pub cmdline: String,
+    pub enable_iommu: bool,
+}
+
+#[derive(Clone, Debug)]
+pub struct CreatedDomain {
+    pub domid: u32,
+    pub store_evtchn: u32,
+    pub store_mfn: u64,
+    pub console_evtchn: u32,
+    pub console_mfn: u64,
+}

crates/xen/xenplatform/src/lib.rs

@@ -6,6 +6,7 @@ pub mod sys;
 
 use crate::error::Error;
 
+pub mod domain;
 pub mod unsupported;
 #[cfg(target_arch = "x86_64")]
 pub mod x86pv;

crates/xen/xenplatform/src/x86pv.rs

@@ -434,9 +434,9 @@ impl X86PvPlatform {
 
 #[async_trait::async_trait]
 impl BootSetupPlatform for X86PvPlatform {
-    fn create_domain(&self, needs_passthrough: bool) -> CreateDomain {
+    fn create_domain(&self, enable_iommu: bool) -> CreateDomain {
         CreateDomain {
-            flags: if needs_passthrough {
+            flags: if enable_iommu {
                 XEN_DOMCTL_CDF_IOMMU
             } else {
                 0
@@ -718,9 +718,8 @@ impl BootSetupPlatform for X86PvPlatform {
         domain.store_mfn = domain.phys.p2m[self.xenstore_segment.as_ref().unwrap().pfn as usize];
         let evtchn = domain.call.evtchn_alloc_unbound(domain.domid, 0).await?;
         let page = domain.alloc_page()?;
-        domain
-            .consoles
-            .push((evtchn, domain.phys.p2m[page.pfn as usize]));
+        domain.console_evtchn = evtchn;
+        domain.console_mfn = domain.phys.p2m[page.pfn as usize];
         self.page_table_segment = self.alloc_page_tables(domain).await?;
         self.boot_stack_segment = Some(domain.alloc_page()?);
 
@@ -802,9 +801,8 @@ impl BootSetupPlatform for X86PvPlatform {
             (*info).flags = 0;
             (*info).store_evtchn = domain.store_evtchn;
             (*info).store_mfn = domain.phys.p2m[xenstore_segment.pfn as usize];
-            let console = domain.consoles.first().unwrap();
-            (*info).console.mfn = console.1;
-            (*info).console.evtchn = console.0;
+            (*info).console.mfn = domain.console_mfn;
+            (*info).console.evtchn = domain.console_evtchn;
             (*info).mod_start = domain.initrd_segment.vstart;
             (*info).mod_len = domain.initrd_segment.size;
             for (i, c) in domain.cmdline.chars().enumerate() {
@@ -893,7 +891,7 @@ impl BootSetupPlatform for X86PvPlatform {
             .as_ref()
             .ok_or(Error::MemorySetupFailed("xenstore_segment missing"))?;
 
-        let console_gfn = domain.consoles.first().map(|x| x.1).unwrap_or(0) as usize;
+        let console_gfn = domain.console_mfn as usize;
         let xenstore_gfn = domain.phys.p2m[xenstore_segment.pfn as usize];
         let addr = domain
             .call