Rename entrypoint field to next_action

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

src/hyperlight_host/src/hypervisor/hyperlight_vm/aarch64.rs

@@ -51,7 +51,7 @@ impl HyperlightVm {
         snapshot_mem: SnapshotSharedMemory<GuestSharedMemory>,
         scratch_mem: GuestSharedMemory,
         root_pt_addr: u64,
-        entrypoint: NextAction,
+        next_action: NextAction,
         rsp_gva: u64,
         page_size: usize,
         config: &SandboxConfiguration,
@@ -84,7 +84,7 @@ impl HyperlightVm {
         let vm_can_reset_vcpu = vm.can_reset_vcpu();
         let mut ret = Self {
             vm,
-            entrypoint,
+            next_action,
             rsp_gva,
             interrupt_handle,
             page_size,
@@ -119,7 +119,7 @@ impl HyperlightVm {
             std::sync::Mutex<SandboxMemoryManager<HostSharedMemory>>,
         >,
     ) -> Result<(), InitializeError> {
-        let NextAction::Initialise(initialise) = self.entrypoint else {
+        let NextAction::Initialise(initialise) = self.next_action else {
             return Ok(());
         };
         let mut x: [u64; 31] = [0; 31];
@@ -149,7 +149,7 @@ impl HyperlightVm {
             return Err(InitializeError::InvalidStackPointer(regs.sp));
         }
         self.rsp_gva = regs.sp;
-        self.entrypoint = NextAction::Call(regs.x[0]);
+        self.next_action = NextAction::Call(regs.x[0]);
 
         Ok(())
     }
@@ -162,7 +162,7 @@ impl HyperlightVm {
             std::sync::Mutex<SandboxMemoryManager<HostSharedMemory>>,
         >,
     ) -> Result<(), DispatchGuestCallError> {
-        let NextAction::Call(dispatch_func_addr) = self.entrypoint else {
+        let NextAction::Call(dispatch_func_addr) = self.next_action else {
             return Err(DispatchGuestCallError::Uninitialized);
         };
         let mut regs = CommonRegisters {

src/hyperlight_host/src/hypervisor/hyperlight_vm/mod.rs

@@ -372,7 +372,7 @@ pub(crate) struct HyperlightVm {
     #[cfg(not(gdb))]
     pub(super) vm: Box<dyn VirtualMachine>,
     pub(super) page_size: usize,
-    pub(super) entrypoint: NextAction, // only present if this vm has not yet been initialised
+    pub(super) next_action: NextAction, // `Initialise` before the guest has run, `Call` afterwards
     pub(super) rsp_gva: u64,
     pub(super) interrupt_handle: Arc<dyn InterruptHandleImpl>,
 
@@ -565,14 +565,14 @@ impl HyperlightVm {
         self.rsp_gva = gva;
     }
 
-    /// Get the current entrypoint action
-    pub(crate) fn get_entrypoint(&self) -> NextAction {
-        self.entrypoint
+    /// Get the next action to perform when the sandbox resumes
+    pub(crate) fn get_next_action(&self) -> NextAction {
+        self.next_action
     }
 
-    /// Set the current entrypoint action
-    pub(crate) fn set_entrypoint(&mut self, entrypoint: NextAction) {
-        self.entrypoint = entrypoint
+    /// Set the next action to perform when the sandbox resumes
+    pub(crate) fn set_next_action(&mut self, next_action: NextAction) {
+        self.next_action = next_action
     }
 
     pub(crate) fn interrupt_handle(&self) -> Arc<dyn InterruptHandle> {

src/hyperlight_host/src/hypervisor/hyperlight_vm/x86_64.rs

@@ -77,7 +77,7 @@ impl HyperlightVm {
         snapshot_mem: SnapshotSharedMemory<GuestSharedMemory>,
         scratch_mem: GuestSharedMemory,
         _root_pt_addr: u64,
-        entrypoint: NextAction,
+        next_action: NextAction,
         rsp_gva: u64,
         page_size: usize,
         #[cfg_attr(target_os = "windows", allow(unused_variables))] config: &SandboxConfiguration,
@@ -141,7 +141,7 @@ impl HyperlightVm {
         #[cfg_attr(not(gdb), allow(unused_mut))]
         let mut ret = Self {
             vm,
-            entrypoint,
+            next_action,
             rsp_gva,
             interrupt_handle,
             page_size,
@@ -183,7 +183,7 @@ impl HyperlightVm {
             // `one_shot_entry_bp` so it does not interfere with later
             // user-installed breakpoints at the same address.
             ret.vm.set_debug(true).map_err(VmError::Debug)?;
-            let entry_addr = match entrypoint {
+            let entry_addr = match next_action {
                 NextAction::Initialise(addr) | NextAction::Call(addr) => Some(addr),
                 #[cfg(test)]
                 NextAction::None => None,
@@ -212,7 +212,7 @@ impl HyperlightVm {
         guest_max_log_level: Option<LevelFilter>,
         #[cfg(gdb)] dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
     ) -> std::result::Result<(), InitializeError> {
-        let NextAction::Initialise(initialise) = self.entrypoint else {
+        let NextAction::Initialise(initialise) = self.next_action else {
             return Ok(());
         };
 
@@ -251,7 +251,7 @@ impl HyperlightVm {
             return Err(InitializeError::InvalidStackPointer(regs.rsp));
         }
         self.rsp_gva = regs.rsp;
-        self.entrypoint = NextAction::Call(regs.rax);
+        self.next_action = NextAction::Call(regs.rax);
 
         Ok(())
     }
@@ -284,7 +284,7 @@ impl HyperlightVm {
         host_funcs: &Arc<Mutex<FunctionRegistry>>,
         #[cfg(gdb)] dbg_mem_access_fn: Arc<Mutex<SandboxMemoryManager<HostSharedMemory>>>,
     ) -> std::result::Result<(), DispatchGuestCallError> {
-        let NextAction::Call(dispatch_func_addr) = self.entrypoint else {
+        let NextAction::Call(dispatch_func_addr) = self.next_action else {
             return Err(DispatchGuestCallError::Uninitialized);
         };
         let mut rflags = 1 << 1; // RFLAGS.1 is RES1
@@ -567,7 +567,7 @@ impl HyperlightVm {
             // Use the stored entry point address from the runtime config.
             // This is the original entry point (load_addr + ELF entry offset)
             // which GDB needs for AT_ENTRY to compute the PIE load offset.
-            // We cannot use self.entrypoint here because it transitions from
+            // We cannot use self.next_action here because it transitions from
             // Initialise(addr) to Call(dispatch_addr) after guest init.
             let initialise = self.rt_cfg.entry_point.unwrap_or_else(|| {
                 tracing::warn!(
@@ -2060,7 +2060,7 @@ mod tests {
 
             // Re-run from entrypoint (flag=1 means guest skips dirty phase, just does FXSAVE)
             // Use stack_top - 8 to match initialise()'s behavior (simulates call pushing return addr)
-            let NextAction::Call(rip) = ctx.ctx.vm.entrypoint else {
+            let NextAction::Call(rip) = ctx.ctx.vm.next_action else {
                 panic!("entrypoint should be call");
             };
             let regs = CommonRegisters {

src/hyperlight_host/src/mem/mgr.rs

@@ -140,8 +140,9 @@ pub(crate) struct SandboxMemoryManager<S: SharedMemory> {
     pub(crate) scratch_mem: S,
     /// The memory layout of the underlying shared memory
     pub(crate) layout: SandboxMemoryLayout,
-    /// Offset for the execution entrypoint from `load_addr`
-    pub(crate) entrypoint: NextAction,
+    /// The next action to perform when this sandbox resumes:
+    /// `Initialise` before the guest has run, `Call` afterwards.
+    pub(crate) next_action: NextAction,
     /// Buffer for accumulating guest abort messages
     pub(crate) abort_buffer: Vec<u8>,
     /// Generation counter: how many snapshots have been taken from
@@ -275,13 +276,13 @@ where
         layout: SandboxMemoryLayout,
         shared_mem: SnapshotSharedMemory<S>,
         scratch_mem: S,
-        entrypoint: NextAction,
+        next_action: NextAction,
     ) -> Self {
         Self {
             layout,
             shared_mem,
             scratch_mem,
-            entrypoint,
+            next_action,
             abort_buffer: Vec::new(),
             snapshot_count: 0,
         }
@@ -300,7 +301,7 @@ where
         root_pt_gpas: &[u64],
         rsp_gva: u64,
         sregs: CommonSpecialRegisters,
-        entrypoint: NextAction,
+        next_action: NextAction,
         host_functions: HostFunctionDetails,
     ) -> Result<Snapshot> {
         self.snapshot_count += 1;
@@ -313,7 +314,7 @@ where
             root_pt_gpas,
             rsp_gva,
             sregs,
-            entrypoint,
+            next_action,
             self.snapshot_count,
             host_functions,
         )
@@ -325,8 +326,8 @@ impl SandboxMemoryManager<ExclusiveSharedMemory> {
         let layout = *s.layout();
         let shared_mem = s.memory().to_mgr_snapshot_mem()?;
         let scratch_mem = ExclusiveSharedMemory::new(s.layout().get_scratch_size())?;
-        let entrypoint = s.entrypoint();
-        let mut mgr = Self::new(layout, shared_mem, scratch_mem, entrypoint);
+        let next_action = s.next_action();
+        let mut mgr = Self::new(layout, shared_mem, scratch_mem, next_action);
         // Inherit the snapshot's generation number for the same
         // reason `restore_snapshot` does: the guest-visible counter
         // reflects "which snapshot is the sandbox currently a clone
@@ -357,15 +358,15 @@ impl SandboxMemoryManager<ExclusiveSharedMemory> {
             shared_mem: hshm,
             scratch_mem: hscratch,
             layout: self.layout,
-            entrypoint: self.entrypoint,
+            next_action: self.next_action,
             abort_buffer: self.abort_buffer,
             snapshot_count: self.snapshot_count,
         };
         let guest_mgr = SandboxMemoryManager {
             shared_mem: gshm,
             scratch_mem: gscratch,
             layout: self.layout,
-            entrypoint: self.entrypoint,
+            next_action: self.next_action,
             abort_buffer: Vec::new(), // Guest doesn't need abort buffer
             snapshot_count: self.snapshot_count,
         };

src/hyperlight_host/src/sandbox/initialized_multi_use.rs

@@ -294,7 +294,7 @@ impl MultiUseSandbox {
         // If the snapshot was taken from an already-initialized guest
         // (NextAction::Call), apply the captured special registers so
         // the guest resumes in the correct CPU state.
-        if matches!(snapshot.entrypoint(), super::snapshot::NextAction::Call(_)) {
+        if matches!(snapshot.next_action(), super::snapshot::NextAction::Call(_)) {
             let sregs = snapshot.sregs().ok_or_else(|| {
                 crate::new_error!("snapshot with NextAction::Call must have captured sregs")
             })?;
@@ -385,7 +385,7 @@ impl MultiUseSandbox {
             .vm
             .get_snapshot_sregs()
             .map_err(|e| HyperlightError::HyperlightVmError(e.into()))?;
-        let entrypoint = self.vm.get_entrypoint();
+        let next_action = self.vm.get_next_action();
         let host_functions = (&*self.host_funcs.try_lock().map_err(|e| {
             crate::new_error!("Error locking host_funcs at {}:{}: {}", file!(), line!(), e)
         })?)
@@ -396,7 +396,7 @@ impl MultiUseSandbox {
             &root_pt_gpas,
             stack_top_gpa,
             sregs,
-            entrypoint,
+            next_action,
             host_functions,
         )?;
         let snapshot = Arc::new(memory_snapshot);
@@ -544,7 +544,7 @@ impl MultiUseSandbox {
             })?;
 
         self.vm.set_stack_top(snapshot.stack_top_gva());
-        self.vm.set_entrypoint(snapshot.entrypoint());
+        self.vm.set_next_action(snapshot.next_action());
 
         let current_regions: Vec<MemoryRegion> = self.vm.get_mapped_regions().cloned().collect();
         for region in &current_regions {

src/hyperlight_host/src/sandbox/snapshot/file/mod.rs

@@ -549,7 +549,7 @@ impl Snapshot {
     }
 
     fn build_config(&self) -> crate::Result<OciSnapshotConfig> {
-        let (entrypoint_addr, sregs) = match (self.entrypoint, self.sregs.as_ref()) {
+        let (entrypoint_addr, sregs) = match (self.next_action, self.sregs.as_ref()) {
             (NextAction::Call(addr), Some(sregs)) => (addr, sregs),
             (NextAction::Call(_), None) => {
                 return Err(crate::new_error!(
@@ -847,8 +847,8 @@ impl Snapshot {
             ));
         }
 
-        // 8. Build entrypoint + sregs back from the config.
-        let entrypoint = NextAction::Call(cfg.entrypoint_addr);
+        // 8. Build the next action + sregs back from the config.
+        let next_action = NextAction::Call(cfg.entrypoint_addr);
 
         // 9. Reconstitute host_functions metadata.
         let snapshot_generation = cfg.snapshot_generation;
@@ -871,7 +871,7 @@ impl Snapshot {
             load_info: crate::mem::exe::LoadInfo::dummy(),
             stack_top_gva: cfg.stack_top_gva,
             sregs: Some(cfg.sregs),
-            entrypoint,
+            next_action,
             snapshot_generation,
             host_functions,
         })

src/hyperlight_host/src/sandbox/snapshot/mod.rs

@@ -93,7 +93,7 @@ pub struct Snapshot {
     sregs: Option<CommonSpecialRegisters>,
 
     /// The next action that should be performed on this snapshot
-    entrypoint: NextAction,
+    next_action: NextAction,
 
     /// The generation number assigned to this snapshot when it was
     /// taken — i.e. "this is the Nth snapshot taken from the sandbox's
@@ -381,7 +381,7 @@ impl Snapshot {
             load_info,
             stack_top_gva: exn_stack_top_gva,
             sregs: None,
-            entrypoint: NextAction::Initialise(load_addr + entrypoint_va - base_va),
+            next_action: NextAction::Initialise(load_addr + entrypoint_va - base_va),
             snapshot_generation: 0,
             host_functions: HostFunctionDetails {
                 host_functions: None,
@@ -407,7 +407,7 @@ impl Snapshot {
         root_pt_gpas: &[u64],
         stack_top_gva: u64,
         sregs: CommonSpecialRegisters,
-        entrypoint: NextAction,
+        next_action: NextAction,
         snapshot_generation: u64,
         host_functions: HostFunctionDetails,
     ) -> Result<Self> {
@@ -560,7 +560,7 @@ impl Snapshot {
             load_info,
             stack_top_gva,
             sregs: Some(sregs),
-            entrypoint,
+            next_action,
             snapshot_generation,
             host_functions,
         })
@@ -603,8 +603,8 @@ impl Snapshot {
         self.sregs.as_ref()
     }
 
-    pub(crate) fn entrypoint(&self) -> NextAction {
-        self.entrypoint
+    pub(crate) fn next_action(&self) -> NextAction {
+        self.next_action
     }
 
     /// Validate that `provided` is a superset of the host functions

src/hyperlight_host/src/sandbox/uninitialized_evolve.rs

@@ -151,13 +151,13 @@ pub(crate) fn set_up_hypervisor_partition(
     let trace_info = MemTraceInfo::new(_load_info.info)?;
 
     // Store the original entry point address in the runtime config for core dumps.
-    // This is needed because `entrypoint` transitions from `Initialise(addr)` to
+    // This is needed because `next_action` transitions from `Initialise(addr)` to
     // `Call(dispatch_addr)` after guest initialisation, losing the original value
     // that GDB needs to compute the PIE binary's load offset.
     #[cfg(crashdump)]
     let rt_cfg = {
         let mut rt_cfg = rt_cfg;
-        if let crate::sandbox::snapshot::NextAction::Initialise(addr) = mgr.entrypoint {
+        if let crate::sandbox::snapshot::NextAction::Initialise(addr) = mgr.next_action {
             rt_cfg.entry_point = Some(addr);
         }
         rt_cfg
@@ -167,7 +167,7 @@ pub(crate) fn set_up_hypervisor_partition(
         mgr.shared_mem,
         mgr.scratch_mem,
         mgr.layout.get_pt_base_gpa(),
-        mgr.entrypoint,
+        mgr.next_action,
         stack_top_gva,
         page_size,
         config,