Remove and prevent use of panic in hyperlight-host

Signed-off-by: Simon Davies <[email protected]>

Author: simongdavies

src/hyperlight_host/src/hypervisor/windows_hypervisor_platform.rs

@@ -104,24 +104,28 @@ impl VMPartition {
         };
 
         regions.iter().try_for_each(|region| unsafe {
+            let flags = region
+                .flags
+                .iter()
+                .map(|flag| match flag {
+                    MemoryRegionFlags::NONE => Ok(WHvMapGpaRangeFlagNone),
+                    MemoryRegionFlags::READ => Ok(WHvMapGpaRangeFlagRead),
+                    MemoryRegionFlags::WRITE => Ok(WHvMapGpaRangeFlagWrite),
+                    MemoryRegionFlags::EXECUTE => Ok(WHvMapGpaRangeFlagExecute),
+                    MemoryRegionFlags::STACK_GUARD => Ok(WHvMapGpaRangeFlagNone),
+                    _ => Err(new_error!("Invalid Memory Region Flag")),
+                })
+                .collect::<Result<Vec<WHV_MAP_GPA_RANGE_FLAGS>>>()?
+                .iter()
+                .fold(WHvMapGpaRangeFlagNone, |acc, flag| acc | *flag); // collect using bitwise OR
+
             let res = whvmapgparange2_func(
                 self.0,
                 process_handle,
                 region.host_region.start as *const c_void,
                 region.guest_region.start as u64,
                 (region.guest_region.end - region.guest_region.start) as u64,
-                region
-                    .flags
-                    .iter()
-                    .filter_map(|flag| match flag {
-                        MemoryRegionFlags::NONE => Some(WHvMapGpaRangeFlagNone),
-                        MemoryRegionFlags::READ => Some(WHvMapGpaRangeFlagRead),
-                        MemoryRegionFlags::WRITE => Some(WHvMapGpaRangeFlagWrite),
-                        MemoryRegionFlags::EXECUTE => Some(WHvMapGpaRangeFlagExecute),
-                        MemoryRegionFlags::STACK_GUARD => None,
-                        _ => panic!("Invalid flag"),
-                    })
-                    .fold(WHvMapGpaRangeFlagNone, |acc, flag| acc | flag), // collect using bitwise OR,
+                flags,
             );
             if res.is_err() {
                 return Err(new_error!("Call to WHvMapGpaRange2 failed"));

src/hyperlight_host/src/lib.rs

@@ -14,6 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+#![cfg_attr(not(any(test, debug_assertions)), warn(clippy::panic))]
 #![cfg_attr(not(any(test, debug_assertions)), warn(clippy::expect_used))]
 
 use std::sync::Once;

src/hyperlight_host/src/sandbox_state/sandbox.rs

@@ -15,12 +15,11 @@ limitations under the License.
 */
 
 use std::fmt::Debug;
-use std::panic;
 
 use tracing::{instrument, Span};
 
 use super::transition::TransitionMetadata;
-use crate::Result;
+use crate::{new_error, Result};
 
 /// The minimal functionality of a Hyperlight sandbox. Most of the types
 /// and operations within this crate require `Sandbox` implementations.
@@ -48,7 +47,9 @@ pub trait Sandbox: Sized + Debug {
     // The default implementation is provided so that types that implement Sandbox (e.g. JSSandbox) but do not need to implement this trait do not need to provide an implementation
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     fn check_stack_guard(&self) -> Result<bool> {
-        panic!("check_stack_guard not implemented for this type");
+        Err(new_error!(
+            "check_stack_guard not implemented for this type"
+        ))
     }
 }