Make it possible to disable execution timeouts

This ensures that setting an execution timeout of 0 disables execution
timeouts entirely. This is temporary, as we intend to remove the
wall-clock timeout feature from Hyperlight entirely in the near
future.

Author: syntactically

src/hyperlight_host/src/hypervisor/hypervisor_handler.rs

@@ -622,13 +622,20 @@ impl HypervisorHandler {
         // from the handler thread, as the thread may be paused by gdb.
         // In this case, we will wait indefinitely for a message from the handler thread.
         // Note: This applies to all the running sandboxes, not just the one being debugged.
-        #[cfg(gdb)]
-        let response = self.communication_channels.from_handler_rx.recv();
         #[cfg(not(gdb))]
-        let response = self
-            .communication_channels
-            .from_handler_rx
-            .recv_timeout(self.execution_variables.get_timeout()?);
+        let timeout = self.execution_variables.get_timeout()?;
+        #[cfg(gdb)]
+        let timeout = Duration::ZERO;
+        let response = if timeout.is_zero() {
+            self.communication_channels
+                .from_handler_rx
+                .recv()
+                .map_err(Into::into)
+        } else {
+            self.communication_channels
+                .from_handler_rx
+                .recv_timeout(timeout)
+        };
 
         match response {
             Ok(msg) => match msg {

src/hyperlight_host/src/sandbox/config.rs

@@ -295,23 +295,25 @@ impl SandboxConfiguration {
         self.kernel_stack_size = max(kernel_stack_size, Self::MIN_KERNEL_STACK_SIZE);
     }
 
-    /// Set the maximum execution time of a guest function execution. If set to 0, the max_execution_time
-    /// will be set to the default value of DEFAULT_MAX_EXECUTION_TIME if the guest execution does not complete within the time specified
-    /// then the execution will be cancelled, the minimum value is MIN_MAX_EXECUTION_TIME
+    /// Set the maximum execution time of a guest function
+    /// execution. If set to 0, the maximum execution time will be
+    /// unlimited. If the guest execution does not complete within the
+    /// time specified, then the execution will be cancelled. The
+    /// minimum value is MIN_MAX_EXECUTION_TIME
     #[instrument(skip_all, parent = Span::current(), level= "Trace")]
     pub fn set_max_execution_time(&mut self, max_execution_time: Duration) {
-        match max_execution_time.as_millis() {
-            0 => self.max_execution_time = Self::DEFAULT_MAX_EXECUTION_TIME,
-            1.. => {
-                self.max_execution_time = min(
-                    Self::MAX_MAX_EXECUTION_TIME.into(),
-                    max(
-                        max_execution_time.as_millis(),
-                        Self::MIN_MAX_EXECUTION_TIME.into(),
-                    ),
-                ) as u16
-            }
-        }
+       match max_execution_time.as_millis() {
+           0 => self.max_execution_time = 0,
+           1.. => {
+               self.max_execution_time = min(
+                   Self::MAX_MAX_EXECUTION_TIME.into(),
+                   max(
+                       max_execution_time.as_millis(),
+                       Self::MIN_MAX_EXECUTION_TIME.into(),
+                   ),
+               ) as u16
+           }
+       }
     }
 
     /// Set the maximum time to wait for guest execution calculation. If set to 0, the maximum cancellation time