feat: fvm-wasm-instrument stack limiter and gas

fvm/Cargo.toml

@@ -39,6 +39,7 @@ log = "0.4.14"
 byteorder = "1.4.3"
 anymap = "0.12.1"
 blake2b_simd = "1.0.0"
+fvm-wasm-instrument = { version = "0.2.0", features = ["bulk"] }
 
 [dependencies.wasmtime]
 version = "0.35.2"

fvm/src/call_manager/default.rs

@@ -1,15 +1,13 @@
-use std::cmp::max;
-
 use anyhow::Context;
 use derive_more::{Deref, DerefMut};
 use fvm_ipld_encoding::{RawBytes, DAG_CBOR};
 use fvm_shared::actor::builtin::Type;
 use fvm_shared::address::{Address, Protocol};
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::{ErrorNumber, ExitCode};
-use fvm_shared::version::NetworkVersion;
 use fvm_shared::{ActorID, MethodNum, METHOD_SEND};
 use num_traits::Zero;
+use wasmtime::Val;
 
 use super::{Backtrace, CallManager, InvocationResult, NO_DATA_BLOCK_ID};
 use crate::call_manager::backtrace::Frame;
@@ -316,7 +314,6 @@ where
         // it returns a referenced copy.
         let engine = self.engine().clone();
 
-        let gas_available = self.gas_tracker.gas_available();
         log::trace!("calling {} -> {}::{}", from, to, method);
         self.map_mut(|cm| {
             // Make the kernel.
@@ -334,21 +331,7 @@ where
             };
 
             // Make a store.
-            let gas_used = kernel.gas_used();
-            let exec_units_to_add = match kernel.network_version() {
-                NetworkVersion::V14 | NetworkVersion::V15 => i64::MAX,
-                _ => kernel
-                    .price_list()
-                    .gas_to_exec_units(max(gas_available.saturating_sub(gas_used), 0), false),
-            };
-
             let mut store = engine.new_store(kernel);
-            if let Err(err) = store.add_fuel(u64::try_from(exec_units_to_add).unwrap_or(0)) {
-                return (
-                    Err(ExecutionError::Fatal(err)),
-                    store.into_data().kernel.into_call_manager(),
-                );
-            }
 
             // Instantiate the module.
             let instance = match engine
@@ -362,6 +345,26 @@ where
 
             // From this point on, there are no more syscall errors, only aborts.
             let result: std::result::Result<RawBytes, Abort> = (|| {
+                let initial_milligas =
+                    store
+                        .data_mut()
+                        .kernel
+                        .borrow_milligas()
+                        .map_err(|e| match e {
+                            ExecutionError::OutOfGas => Abort::OutOfGas,
+                            ExecutionError::Fatal(m) => Abort::Fatal(m),
+                            _ => Abort::Fatal(anyhow::Error::msg(
+                                "setting available gas on entering wasm",
+                            )),
+                        })?;
+
+                store
+                    .data()
+                    .avail_gas_global
+                    .clone()
+                    .set(&mut store, Val::I64(initial_milligas))
+                    .map_err(Abort::Fatal)?;
+
                 // Lookup the invoke method.
                 let invoke: wasmtime::TypedFunc<(u32,), u32> = instance
                     .get_typed_func(&mut store, "invoke")
@@ -371,19 +374,26 @@ where
                 // Invoke it.
                 let res = invoke.call(&mut store, (param_id,));
 
-                // Charge gas for the "latest" use of execution units (all the exec units used since the most recent syscall)
-                // We do this by first loading the _total_ execution units consumed
-                let exec_units_consumed = store
-                    .fuel_consumed()
-                    .context("expected to find fuel consumed")
-                    .map_err(Abort::Fatal)?;
-                // Then, pass the _total_ exec_units_consumed to the InvocationData,
-                // which knows how many execution units had been consumed at the most recent snapshot
-                // It will charge gas for the delta between the total units (the number we provide) and its snapshot
+                // Return gas tracking to GasTracker
+                let available_milligas =
+                    match store.data_mut().avail_gas_global.clone().get(&mut store) {
+                        Val::I64(g) => Ok(g),
+                        _ => Err(Abort::Fatal(anyhow::Error::msg(
+                            "failed to get available gas from wasm after returning",
+                        ))),
+                    }?;
+
                 store
                     .data_mut()
-                    .charge_gas_for_exec_units(exec_units_consumed)
-                    .map_err(|e| Abort::from_error(ExitCode::SYS_ASSERTION_FAILED, e))?;
+                    .kernel
+                    .return_milligas("wasm_exec_last", available_milligas)
+                    .map_err(|e| match e {
+                        ExecutionError::OutOfGas => Abort::OutOfGas,
+                        ExecutionError::Fatal(m) => Abort::Fatal(m),
+                        _ => Abort::Fatal(anyhow::Error::msg(
+                            "setting available gas on existing wasm",
+                        )),
+                    })?;
 
                 // If the invocation failed due to running out of exec_units, we have already detected it and returned OutOfGas above.
                 // Any other invocation failure is returned here as an Abort

fvm/src/gas/mod.rs

@@ -3,61 +3,136 @@
 
 pub use self::charge::GasCharge;
 pub(crate) use self::outputs::GasOutputs;
-pub use self::price_list::{price_list_by_network_version, PriceList};
+pub use self::price_list::{price_list_by_network_version, PriceList, WasmGasPrices};
 use crate::kernel::{ExecutionError, Result};
 
 mod charge;
 mod outputs;
 mod price_list;
 
+pub const MILLIGAS_PRECISION: i64 = 1000;
+
 pub struct GasTracker {
-    gas_available: i64,
-    gas_used: i64,
+    milligas_limit: i64,
+    milligas_used: i64,
+
+    /// A flag indicating whether this GasTracker is currently responsible for
+    /// gas accounting. A 'false' value indicates that gas accounting is
+    /// handled somewhere else (eg. in wasm execution).
+    ///
+    /// Creating gas charges is only allowed when own_limit is true.
+    own_limit: bool,
 }
 
 impl GasTracker {
-    pub fn new(gas_available: i64, gas_used: i64) -> Self {
+    pub fn new(gas_limit: i64, gas_used: i64) -> Self {
         Self {
-            gas_available,
-            gas_used,
+            milligas_limit: gas_to_milligas(gas_limit),
+            milligas_used: gas_to_milligas(gas_used),
+            own_limit: true,
         }
     }
 
     /// Safely consumes gas and returns an out of gas error if there is not sufficient
     /// enough gas remaining for charge.
-    pub fn charge_gas(&mut self, charge: GasCharge) -> Result<()> {
-        let to_use = charge.total();
-        match self.gas_used.checked_add(to_use) {
+    fn charge_milligas(&mut self, name: &str, to_use: i64) -> Result<()> {
+        if !self.own_limit {
+            return Err(ExecutionError::Fatal(anyhow::Error::msg(
+                "charge_gas called when gas_limit owned by execution",
+            )));
+        }
+
+        match self.milligas_used.checked_add(to_use) {
             None => {
-                log::trace!("gas overflow: {}", charge.name);
-                self.gas_used = self.gas_available;
+                log::trace!("gas overflow: {}", name);
+                self.milligas_used = self.milligas_limit;
                 Err(ExecutionError::OutOfGas)
             }
             Some(used) => {
-                log::trace!("charged {} gas: {}", to_use, charge.name);
-                if used > self.gas_available {
-                    log::trace!("out of gas: {}", charge.name);
-                    self.gas_used = self.gas_available;
+                log::trace!("charged {} gas: {}", to_use, name);
+                if used > self.milligas_limit {
+                    log::trace!("out of gas: {}", name);
+                    self.milligas_used = self.milligas_limit;
                     Err(ExecutionError::OutOfGas)
                 } else {
-                    self.gas_used = used;
+                    self.milligas_used = used;
                     Ok(())
                 }
             }
         }
     }
 
+    pub fn charge_gas(&mut self, charge: GasCharge) -> Result<()> {
+        self.charge_milligas(
+            charge.name,
+            charge.total().saturating_mul(MILLIGAS_PRECISION),
+        )
+    }
+
+    /// returns available milligas; makes the gas tracker reject gas charges with
+    /// a fatal error until return_milligas is called.
+    pub fn borrow_milligas(&mut self) -> Result<i64> {
+        if !self.own_limit {
+            return Err(ExecutionError::Fatal(anyhow::Error::msg(
+                "borrow_milligas called on GasTracker which doesn't own gas limit",
+            )));
+        }
+        self.own_limit = false;
+
+        Ok(self.milligas_limit - self.milligas_used)
+    }
+
+    /// sets new available gas, creating a new gas charge if needed
+    pub fn return_milligas(&mut self, name: &str, new_avail_mgas: i64) -> Result<()> {
+        if self.own_limit {
+            return Err(ExecutionError::Fatal(anyhow::Error::msg(format!(
+                "gastracker already owns gas_limit, charge: {}",
+                name
+            ))));
+        }
+        self.own_limit = true;
+
+        let old_avail_milligas = self.milligas_limit - self.milligas_used;
+        let used = old_avail_milligas - new_avail_mgas;
+
+        if used < 0 {
+            return Err(ExecutionError::Fatal(anyhow::Error::msg(
+                "negative gas charge in set_available_gas",
+            )));
+        }
+
+        self.charge_milligas(name, used)
+    }
+
     /// Getter for gas available.
-    pub fn gas_available(&self) -> i64 {
-        self.gas_available
+    pub fn gas_limit(&self) -> i64 {
+        milligas_to_gas(self.milligas_limit, false)
     }
 
     /// Getter for gas used.
     pub fn gas_used(&self) -> i64 {
-        self.gas_used
+        milligas_to_gas(self.milligas_used, true)
     }
 }
 
+/// Converts the specified gas into equivalent fractional gas units
+#[inline]
+fn gas_to_milligas(gas: i64) -> i64 {
+    gas.saturating_mul(MILLIGAS_PRECISION)
+}
+
+/// Converts the specified fractional gas units into gas units
+#[inline]
+fn milligas_to_gas(milligas: i64, round_up: bool) -> i64 {
+    let mut div_result = milligas / MILLIGAS_PRECISION;
+    if milligas > 0 && round_up && milligas % MILLIGAS_PRECISION != 0 {
+        div_result = div_result.saturating_add(1);
+    } else if milligas < 0 && !round_up && milligas % MILLIGAS_PRECISION != 0 {
+        div_result = div_result.saturating_sub(1);
+    }
+    div_result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -71,4 +146,12 @@ mod tests {
         assert_eq!(t.gas_used(), 20);
         assert!(t.charge_gas(GasCharge::new("", 1, 0)).is_err())
     }
+
+    #[test]
+    fn milligas_to_gas_round() {
+        assert_eq!(milligas_to_gas(100, false), 0);
+        assert_eq!(milligas_to_gas(100, true), 1);
+        assert_eq!(milligas_to_gas(-100, false), -1);
+        assert_eq!(milligas_to_gas(-100, true), 0);
+    }
 }