changes to support GHCI failure message handling

Signed-off-by: Gudaram, Meghana <[email protected]>

Author: mgudaram

src/migtd/src/bin/migtd/cvmemu.rs

@@ -10,6 +10,7 @@
 use std::env;
 use std::process;
 
+use alloc::vec::Vec;
 use migtd;
 use migtd::migration::event;
 use migtd::migration::logging::{create_logarea, enable_logarea};
@@ -439,9 +440,10 @@ fn handle_pre_mig_emu() -> i32 {
                         }
                         WaitForRequestResponse::StartMigration(req) => {
                             log::info!("Processing StartMigration request\n");
+                            let mut data = Vec::new();
 
                             // Call exchange_msk() and log its immediate outcome
-                            let res = exchange_msk(&req).await;
+                            let res = exchange_msk(&req, &mut data).await;
                             match &res {
                                 Ok(_) => log::info!("exchange_msk() returned Ok\n"),
                                 Err(e) => {

src/migtd/src/bin/migtd/main.rs

@@ -14,7 +14,6 @@ use core::task::Poll;
 use alloc::format;
 #[cfg(feature = "policy_v2")]
 use alloc::string::String;
-#[cfg(feature = "vmcall-raw")]
 use alloc::vec::Vec;
 use log::info;
 #[cfg(feature = "vmcall-raw")]
@@ -283,6 +282,7 @@ fn handle_pre_mig() {
     loop {
         // Poll the async runtime to execute tasks
         let _ = async_runtime::poll_tasks();
+        let mut data: Vec<u8> = Vec::new();
 
         // The async task waiting for VMM response is always in the queue
         let new_request = PENDING_REQUEST.lock().take();
@@ -291,7 +291,7 @@ fn handle_pre_mig() {
             async_runtime::add_task(async move {
                 #[cfg(not(feature = "vmcall-raw"))]
                 {
-                    let status = exchange_msk(&request)
+                    let status = exchange_msk(&request, &mut data)
                         .await
                         .map(|_| MigrationResult::Success)
                         .unwrap_or_else(|e| e);
@@ -301,10 +301,9 @@ fn handle_pre_mig() {
                 }
                 #[cfg(feature = "vmcall-raw")]
                 {
-                    let mut data: Vec<u8> = Vec::new();
                     match request {
                         WaitForRequestResponse::StartMigration(wfr_info) => {
-                            let status = exchange_msk(&wfr_info)
+                            let status = exchange_msk(&wfr_info, &mut data)
                                 .await
                                 .map(|_| MigrationResult::Success)
                                 .unwrap_or_else(|e| e);

src/migtd/src/migration/logging.rs

@@ -154,6 +154,10 @@ pub async fn enable_logarea(log_max_level: u8, request_id: u64, data: &mut Vec<u
         .load(Ordering::SeqCst);
 
     if !logarea_created {
+        data.extend_from_slice(
+            &format!("Error: LogArea has not been successfuly created by create_logarea()\n")
+                .into_bytes(),
+        );
         return Err(MigrationResult::UnsupportedOperationError);
     }
 
@@ -235,6 +239,13 @@ pub async fn enable_logarea(log_max_level: u8, request_id: u64, data: &mut Vec<u
             Level::Error,
             request_id,
         );
+        data.extend_from_slice(
+            &format!(
+                "Error: enable_logarea(): Invalid MaxLogLevel: {:x} requested\n",
+                log_max_level
+            )
+            .into_bytes(),
+        );
         return Err(MigrationResult::InvalidParameter);
     }
 }

src/migtd/src/migration/session.rs

@@ -475,6 +475,9 @@ pub async fn get_tdreport(
             Level::Debug,
             request_id,
         );
+        data.extend_from_slice(
+            &format!("Error: get_tdreport(): TDG.MR.REPORT failure {:x}\n", ret).into_bytes(),
+        );
         return Err(MigrationResult::TdxModuleError);
     }
 
@@ -490,6 +493,11 @@ pub async fn get_tdreport(
             Level::Debug,
             request_id,
         );
+        data.extend_from_slice(&format!(
+                "Error: get_tdreport(): tdreport incorrect data length - expected {:x} actual {:x}\n",
+                tdreportsize,
+                data.len()
+            ).into_bytes());
         return Err(MigrationResult::InvalidParameter);
     }
     Ok(())
@@ -776,7 +784,9 @@ async fn pre_session_data_exchange<T: AsyncRead + AsyncWrite + Unpin>(
 }
 
 #[cfg(feature = "main")]
-pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
+pub async fn exchange_msk(info: &MigrationInformation, data: &mut Vec<u8>) -> Result<()> {
+    #[cfg(not(feature = "vmcall-raw"))]
+    let _ = data;
     #[cfg(feature = "policy_v2")]
     let mut transport;
     #[cfg(not(feature = "policy_v2"))]
@@ -786,12 +796,18 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
     {
         use vmcall_raw::stream::VmcallRaw;
         let mut vmcall_raw_instance = VmcallRaw::new_with_mid(info.mig_info.mig_request_id)
-            .map_err(|_e| MigrationResult::InvalidParameter)?;
+            .map_err(|e| {
+                data.extend_from_slice(&format!("Error: exchange_msk(): Failed to create vmcall_raw_instance with Migration ID: {:x} errorcode: {}\n", info.mig_info.mig_request_id, e).into_bytes());
+                MigrationResult::InvalidParameter
+        })?;
 
         vmcall_raw_instance
             .connect()
             .await
-            .map_err(|_e| MigrationResult::InvalidParameter)?;
+            .map_err(|e| {
+                data.extend_from_slice(&format!("Error: exchange_msk(): Failed to connect vmcall_raw_instance with Migration ID: {:x} errorcode: {}\n", info.mig_info.mig_request_id, e).into_bytes());
+                MigrationResult::InvalidParameter
+            })?;
         transport = vmcall_raw_instance;
     }
 
@@ -849,8 +865,20 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
                 transport,
                 #[cfg(feature = "policy_v2")]
                 remote_policy,
+                #[cfg(feature = "vmcall-raw")]
+                data,
             )
-            .map_err(|_| MigrationResult::SecureSessionError)?;
+            .map_err(|_| {
+                #[cfg(feature = "vmcall-raw")]
+                data.extend_from_slice(
+                    &format!(
+                        "Error: exchange_msk(): Failed in ratls transport. Migration ID: {:x}\n",
+                        info.mig_info.mig_request_id
+                    )
+                    .into_bytes(),
+                );
+                MigrationResult::SecureSessionError
+            })?;
 
             // MigTD-S send Migration Session Forward key to peer
             with_timeout(
@@ -864,6 +892,16 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
             )
             .await??;
             if size < size_of::<ExchangeInformation>() {
+                #[cfg(feature = "vmcall-raw")]
+                data.extend_from_slice(
+                    &format!(
+                        "Error: exchange_msk(): Incorrect ExchangeInformation size Migration ID: {:x}. Size - Expected: {:x} Actual: {:x}\n",
+                        info.mig_info.mig_request_id,
+                        size_of::<ExchangeInformation>(),
+                        size
+                    )
+                    .into_bytes(),
+                );
                 return Err(MigrationResult::NetworkError);
             }
             #[cfg(all(not(feature = "virtio-serial"), not(feature = "vmcall-raw")))]
@@ -874,15 +912,35 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
                 .transport_mut()
                 .shutdown()
                 .await
-                .map_err(|_e| MigrationResult::InvalidParameter)?;
+                .map_err(|e| {
+                    data.extend_from_slice(
+                        &format!(
+                            "Error: exchange_msk(): Failed to transport in vmcall_raw_instance with Migration ID: {:x} errorcode: {}\n",
+                            info.mig_info.mig_request_id,
+                            e
+                        )
+                        .into_bytes(),
+                    );
+                    MigrationResult::InvalidParameter
+                })?;
         } else {
             // TLS server
             let mut ratls_server = ratls::server(
                 transport,
                 #[cfg(feature = "policy_v2")]
                 remote_policy,
             )
-            .map_err(|_| MigrationResult::SecureSessionError)?;
+            .map_err(|_| {
+                #[cfg(feature = "vmcall-raw")]
+                data.extend_from_slice(
+                    &format!(
+                        "Error: exchange_msk(): Failed in ratls transport. Migration ID: {:x}\n",
+                        info.mig_info.mig_request_id
+                    )
+                    .into_bytes(),
+                );
+                MigrationResult::SecureSessionError
+            })?;
 
             with_timeout(
                 TLS_TIMEOUT,
@@ -895,6 +953,8 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
             )
             .await??;
             if size < size_of::<ExchangeInformation>() {
+                #[cfg(feature = "vmcall-raw")]
+                data.extend_from_slice(&format!("Error: exchange_msk(): Incorrect ExchangeInformation size Migration ID: {:x}. Size - Expected: {:x} Actual: {:x}\n", info.mig_info.mig_request_id, size_of::<ExchangeInformation>(), size).into_bytes());
                 return Err(MigrationResult::NetworkError);
             }
             #[cfg(all(not(feature = "virtio-serial"), not(feature = "vmcall-raw")))]
@@ -905,7 +965,10 @@ pub async fn exchange_msk(info: &MigrationInformation) -> Result<()> {
                 .transport_mut()
                 .shutdown()
                 .await
-                .map_err(|_e| MigrationResult::InvalidParameter)?;
+                .map_err(|e| {
+                    data.extend_from_slice(&format!("Error: exchange_msk(): Failed to transport in vmcall_raw_instance with Migration ID: {:x} errorcode: {}\n", info.mig_info.mig_request_id, e).into_bytes());
+                    MigrationResult::InvalidParameter
+                })?;
         }
 
         let mig_ver = cal_mig_version(info.is_src(), &exchange_information, &remote_information)?;

src/migtd/src/ratls/server_client.rs

@@ -45,6 +45,7 @@ pub fn server<T: AsyncRead + AsyncWrite + Unpin>(
 pub fn client<T: AsyncRead + AsyncWrite + Unpin>(
     stream: T,
     #[cfg(feature = "policy_v2")] remote_policy: Vec<u8>,
+    #[cfg(feature = "vmcall-raw")] data: &mut Vec<u8>,
 ) -> Result<SecureChannel<T>> {
     let signing_key = EcdsaPk::new()?;
     let (certs, quote) = gen_cert(&signing_key)?;
@@ -58,7 +59,17 @@ pub fn client<T: AsyncRead + AsyncWrite + Unpin>(
     let config = TlsConfig::new(certs, signing_key, verify_server_cert, quote)?;
     #[cfg(feature = "policy_v2")]
     let config = TlsConfig::new(certs, signing_key, verify_server_cert, remote_policy)?;
-    config.tls_client(stream).map_err(|e| e.into())
+    config.tls_client(stream).map_err(|e| {
+        #[cfg(feature = "vmcall-raw")]
+        data.extend_from_slice(
+            &format!(
+                "Error: server_client client(): Failure in tls_client() error: {:?}\n",
+                e
+            )
+            .into_bytes(),
+        );
+        e.into()
+    })
 }
 
 fn gen_cert(signing_key: &EcdsaPk) -> Result<(Vec<u8>, Vec<u8>)> {