actor upgrade error refactor

fvm/src/call_manager/default.rs

@@ -231,9 +231,6 @@ where
                     ExecutionEvent::CallError(SyscallError::new(ErrorNumber::Forbidden, "fatal"))
                 }
                 Err(ExecutionError::Syscall(s)) => ExecutionEvent::CallError(s.clone()),
-                Err(ExecutionError::Abort(_)) => {
-                    ExecutionEvent::CallError(SyscallError::new(ErrorNumber::Forbidden, "aborted"))
-                }
             });
         }
 
@@ -723,9 +720,10 @@ where
 
             // From this point on, there are no more syscall errors, only aborts.
             let result: std::result::Result<BlockId, Abort> = (|| {
+                let code = &state.code;
                 // Instantiate the module.
                 let instance = engine
-                    .instantiate(&mut store, &state.code)?
+                    .instantiate(&mut store, code)?
                     .context("actor not found")
                     .map_err(Abort::Fatal)?;
 
@@ -740,7 +738,11 @@ where
                 let func = match instance.get_func(&mut store, entrypoint.func_name()) {
                     Some(func) => func,
                     None => {
-                        return Err(Abort::EntrypointNotFound);
+                        return Err(Abort::Exit(
+                            ExitCode::SYS_INVALID_RECEIVER,
+                            format!("cannot upgrade to {code}"),
+                            0,
+                        ));
                     }
                 };
 
@@ -812,14 +814,6 @@ where
                                 Err(ExecutionError::Fatal(anyhow!(e))),
                             ),
                         },
-                        Abort::EntrypointNotFound => (
-                            ExitCode::USR_FORBIDDEN,
-                            "entrypoint not found".to_owned(),
-                            Err(ExecutionError::Syscall(SyscallError::new(
-                                ErrorNumber::Forbidden,
-                                "entrypoint not found",
-                            ))),
-                        ),
                         Abort::OutOfGas => (
                             ExitCode::SYS_OUT_OF_GAS,
                             "out of gas".to_owned(),

fvm/src/call_manager/mod.rs

@@ -10,10 +10,9 @@ use fvm_shared::{ActorID, MethodNum};
 
 use crate::engine::Engine;
 use crate::gas::{Gas, GasCharge, GasTimer, GasTracker, PriceList};
-use crate::kernel::{self, BlockRegistry, Result};
+use crate::kernel::{self, BlockRegistry, ClassifyResult, Context, Result};
 use crate::machine::{Machine, MachineContext};
 use crate::state_tree::ActorState;
-use crate::syscalls::error::Abort;
 use crate::Kernel;
 
 pub mod backtrace;
@@ -235,9 +234,9 @@ impl Entrypoint {
         match self {
             Entrypoint::Invoke(_) => Ok(Vec::new()),
             Entrypoint::Upgrade(ui) => {
-                let ui_params = to_vec(&ui).map_err(|e| {
-                    Abort::Fatal(anyhow::anyhow!("failed to serialize upgrade params: {}", e))
-                })?;
+                let ui_params = to_vec(&ui)
+                    .or_fatal()
+                    .context("failed to serialize upgrade params")?;
                 // This is CBOR instead of DAG_CBOR because these params are not reachable
                 let block_id = br.put_reachable(kernel::Block::new(CBOR, ui_params, Vec::new()))?;
                 Ok(vec![wasmtime::Val::I32(block_id as i32)])

fvm/src/executor/default.rs

@@ -201,9 +201,6 @@ where
                     events_root,
                 }
             }
-
-            Err(ExecutionError::Abort(e)) => return Err(anyhow!("actor aborted: {}", e)),
-
             Err(ExecutionError::OutOfGas) => Receipt {
                 exit_code: ExitCode::SYS_OUT_OF_GAS,
                 return_data: Default::default(),

fvm/src/kernel/default.rs

@@ -5,7 +5,6 @@ use std::convert::{TryFrom, TryInto};
 use std::panic::{self, UnwindSafe};
 use std::path::PathBuf;
 
-use crate::syscalls::error::Abort;
 use anyhow::{anyhow, Context as _};
 use cid::Cid;
 use filecoin_proofs_api::{self as proofs, ProverId, PublicReplicaInfo, SectorId};
@@ -874,7 +873,11 @@ where
             .create_actor(code_id, actor_id, delegated_address)
     }
 
-    fn upgrade_actor<K: Kernel>(&mut self, new_code_cid: Cid, params_id: BlockId) -> Result<u32> {
+    fn upgrade_actor<K: Kernel>(
+        &mut self,
+        new_code_cid: Cid,
+        params_id: BlockId,
+    ) -> Result<SendResult> {
         if self.read_only {
             return Err(
                 syscall_error!(ReadOnly, "upgrade_actor cannot be called while read-only").into(),
@@ -938,27 +941,18 @@ where
         });
 
         match result {
-            Ok(InvocationResult {
-                exit_code: ExitCode::OK,
-                value,
-            }) => {
-                let block_id = match value {
-                    None => NO_DATA_BLOCK_ID,
-                    Some(block) => self.blocks.put_reachable(block).unwrap_or_else(|_| {
-                        log::error!("failed to write to kernel block registry");
-                        NO_DATA_BLOCK_ID
-                    }),
+            Ok(InvocationResult { exit_code, value }) => {
+                let (block_stat, block_id) = match value {
+                    None => (BlockStat { codec: 0, size: 0 }, NO_DATA_BLOCK_ID),
+                    // TODO: Check error cases. At a minimum, we could run out of gas here!
+                    Some(block) => (block.stat(), self.blocks.put_reachable(block)?),
                 };
-                Err(ExecutionError::Abort(Abort::Exit(
-                    ExitCode::OK,
-                    "actor upgraded".to_string(),
+                Ok(SendResult {
                     block_id,
-                )))
+                    block_stat,
+                    exit_code,
+                })
             }
-            Ok(InvocationResult {
-                exit_code,
-                value: _,
-            }) => Ok(exit_code.value()),
             Err(err) => Err(err),
         }
     }

fvm/src/kernel/error.rs

@@ -5,8 +5,6 @@ use std::fmt::Display;
 use derive_more::Display;
 use fvm_shared::error::ErrorNumber;
 
-use crate::syscalls::error::Abort;
-
 /// Execution result.
 pub type Result<T> = std::result::Result<T, ExecutionError>;
 
@@ -37,7 +35,6 @@ pub enum ExecutionError {
     OutOfGas,
     Syscall(SyscallError),
     Fatal(anyhow::Error),
-    Abort(Abort),
 }
 
 impl ExecutionError {
@@ -55,7 +52,6 @@ impl ExecutionError {
         match self {
             Fatal(_) => true,
             OutOfGas | Syscall(_) => false,
-            Abort(_) => true,
         }
     }
 
@@ -65,7 +61,7 @@ impl ExecutionError {
         use ExecutionError::*;
         match self {
             Syscall(_) => true,
-            OutOfGas | Fatal(_) | Abort(_) => false,
+            OutOfGas | Fatal(_) => false,
         }
     }
 }
@@ -78,12 +74,6 @@ impl From<SyscallError> for ExecutionError {
     }
 }
 
-impl From<Abort> for ExecutionError {
-    fn from(e: Abort) -> Self {
-        ExecutionError::Abort(e)
-    }
-}
-
 pub trait ClassifyResult: Sized {
     type Value;
     type Error;
@@ -158,7 +148,6 @@ impl Context for ExecutionError {
             Syscall(e) => Syscall(SyscallError(format!("{}: {}", context, e.0), e.1)),
             Fatal(e) => Fatal(e.context(context.to_string())),
             OutOfGas => OutOfGas, // no reason necessary
-            Abort(_) => self,
         }
     }
 
@@ -179,7 +168,6 @@ impl From<ExecutionError> for anyhow::Error {
             OutOfGas => anyhow::anyhow!("out of gas"),
             Syscall(err) => anyhow::anyhow!(err.0),
             Fatal(err) => err,
-            Abort(e) => anyhow::anyhow!("aborted: {}", e),
         }
     }
 }

fvm/src/kernel/mod.rs

@@ -209,7 +209,11 @@ pub trait ActorOps {
         delegated_address: Option<Address>,
     ) -> Result<()>;
 
-    fn upgrade_actor<K: Kernel>(&mut self, new_code_cid: Cid, params_id: BlockId) -> Result<u32>;
+    fn upgrade_actor<K: Kernel>(
+        &mut self,
+        new_code_cid: Cid,
+        params_id: BlockId,
+    ) -> Result<SendResult>;
 
     /// Installs actor code pointed by cid
     #[cfg(feature = "m2-native")]

fvm/src/syscalls/actor.rs

@@ -3,8 +3,10 @@
 use anyhow::{anyhow, Context as _};
 use fvm_shared::{sys, ActorID};
 
+use super::bind::ControlFlow;
+use super::error::Abort;
 use super::Context;
-use crate::kernel::{ClassifyResult, Result};
+use crate::kernel::{ClassifyResult, Result, SendResult};
 use crate::{syscall_error, Kernel};
 
 pub fn resolve_address(
@@ -113,10 +115,31 @@ pub fn upgrade_actor<K: Kernel>(
     context: Context<'_, K>,
     new_code_cid_off: u32,
     params_id: u32,
-) -> Result<u32> {
-    let cid = context.memory.read_cid(new_code_cid_off)?;
-
-    context.kernel.upgrade_actor::<K>(cid, params_id)
+) -> ControlFlow<sys::out::send::Send> {
+    let cid = match context.memory.read_cid(new_code_cid_off) {
+        Ok(cid) => cid,
+        Err(err) => return err.into(),
+    };
+
+    match context.kernel.upgrade_actor::<K>(cid, params_id) {
+        Ok(SendResult {
+            block_id,
+            block_stat,
+            exit_code,
+        }) => {
+            if exit_code.is_success() {
+                ControlFlow::Abort(Abort::Exit(exit_code, String::new(), block_id))
+            } else {
+                ControlFlow::Return(sys::out::send::Send {
+                    exit_code: exit_code.value(),
+                    return_id: block_id,
+                    return_codec: block_stat.codec,
+                    return_size: block_stat.size,
+                })
+            }
+        }
+        Err(err) => err.into(),
+    }
 }
 
 pub fn get_builtin_actor_type(