Merge pull request #470 from CosmWasm/fix-GAS_LIMIT

Increase GAS_LIMIT by a lot and stabilize set_gas_limit

Author: webmaster128

CHANGELOG.md

@@ -11,6 +11,10 @@
 **cosmwasm-vm**
 
 - Remove unused cache size argument from `CosmCache`.
+- `set_gas_limit` now panics if the given gas limit exceeds the max. supported
+  value.
+- Increase the max. supported value for gas limit from 10_000_000_000 to
+  0x7FFFFFFFFFFFFFFF.
 
 ## 0.9.3 (2020-07-08)
 

packages/vm/src/backends/singlepass.rs

@@ -12,15 +12,16 @@ use wasmer_singlepass_backend::ModuleCodeGenerator as SinglePassMCG;
 use crate::errors::VmResult;
 use crate::middleware::DeterministicMiddleware;
 
-/// In Wasmer, The gas limit on instances is set during compile time and is included in the compiled binaries.
-/// This causes issues when trying to reuse the same precompiled binaries for another instance with a different
-/// gas limit.
-/// https://github.com/wasmerio/wasmer/pull/996
-/// To work around that, we set the gas limit of all Wasmer instances to this very-high gas limit value, under
-/// the assumption that users won't request more than this amount of gas. Then to set a gas limit below that figure,
-/// we pretend to consume the difference between the two in `set_gas_limit`, so the amount of units left is equal to
-/// the requested gas limit.
-pub const GAS_LIMIT: u64 = 10_000_000_000;
+/// In Wasmer, the gas limit is set on modules during compilation and is included in the cached modules.
+/// This causes issues when trying to instantiate the same compiled module with a different gas limit.
+/// A fix for this is proposed here: https://github.com/wasmerio/wasmer/pull/996.
+///
+/// To work around this limitation, we set the gas limit of all Wasmer instances to this very high value,
+/// assuming users won't request more than this amount of gas. In order to set the real gas limit, we pretend
+/// to consume the difference between the two in `set_gas_limit` ("points used" in the metering middleware).
+/// Since we observed overflow behaviour in the points used, we ensure both MAX_GAS_LIMIT and points used stay
+/// far below u64::MAX.
+const MAX_GAS_LIMIT: u64 = u64::MAX / 2;
 
 pub fn compile(code: &[u8]) -> VmResult<Module> {
     let module = compile_with(code, compiler().as_ref())?;
@@ -31,7 +32,7 @@ pub fn compiler() -> Box<dyn Compiler> {
     let c: StreamingCompiler<SinglePassMCG, _, _, _, _> = StreamingCompiler::new(move || {
         let mut chain = MiddlewareChain::new();
         chain.push(DeterministicMiddleware::new());
-        chain.push(metering::Metering::new(GAS_LIMIT));
+        chain.push(metering::Metering::new(MAX_GAS_LIMIT));
         chain
     });
     Box::new(c)
@@ -43,13 +44,75 @@ pub fn backend() -> &'static str {
 
 /// Set the amount of gas units that can be used in the instance.
 pub fn set_gas_limit(instance: &mut WasmerInstance, limit: u64) {
-    let used = GAS_LIMIT.saturating_sub(limit);
-    metering::set_points_used(instance, used)
+    if limit > MAX_GAS_LIMIT {
+        panic!(
+            "Attempted to set gas limit larger than max gas limit (got: {}; maximum: {}).",
+            limit, MAX_GAS_LIMIT
+        );
+    } else {
+        let used = MAX_GAS_LIMIT - limit;
+        metering::set_points_used(instance, used);
+    }
 }
 
 /// Get how many more gas units can be used in the instance.
 pub fn get_gas_left(instance: &WasmerInstance) -> u64 {
     let used = metering::get_points_used(instance);
-    // when running out of gas, get_points_used can exceed GAS_LIMIT
-    GAS_LIMIT.saturating_sub(used)
+    // when running out of gas, get_points_used can exceed MAX_GAS_LIMIT
+    MAX_GAS_LIMIT.saturating_sub(used)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use wabt::wat2wasm;
+    use wasmer_runtime_core::imports;
+
+    fn instantiate(code: &[u8]) -> WasmerInstance {
+        let module = compile(code).unwrap();
+        let import_obj = imports! { "env" => {}, };
+        module.instantiate(&import_obj).unwrap()
+    }
+
+    #[test]
+    fn get_gas_left_defaults_to_constant() {
+        let wasm = wat2wasm("(module)").unwrap();
+        let instance = instantiate(&wasm);
+        let gas_left = get_gas_left(&instance);
+        assert_eq!(gas_left, MAX_GAS_LIMIT);
+    }
+
+    #[test]
+    fn set_gas_limit_works() {
+        let wasm = wat2wasm("(module)").unwrap();
+        let mut instance = instantiate(&wasm);
+
+        let limit = 3456789;
+        set_gas_limit(&mut instance, limit);
+        assert_eq!(get_gas_left(&instance), limit);
+
+        let limit = 1;
+        set_gas_limit(&mut instance, limit);
+        assert_eq!(get_gas_left(&instance), limit);
+
+        let limit = 0;
+        set_gas_limit(&mut instance, limit);
+        assert_eq!(get_gas_left(&instance), limit);
+
+        let limit = MAX_GAS_LIMIT;
+        set_gas_limit(&mut instance, limit);
+        assert_eq!(get_gas_left(&instance), limit);
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Attempted to set gas limit larger than max gas limit (got: 9223372036854775808; maximum: 9223372036854775807)."
+    )]
+    fn set_gas_limit_panic_for_values_too_large() {
+        let wasm = wat2wasm("(module)").unwrap();
+        let mut instance = instantiate(&wasm);
+
+        let limit = MAX_GAS_LIMIT + 1;
+        set_gas_limit(&mut instance, limit);
+    }
 }

packages/vm/src/context.rs

@@ -363,10 +363,7 @@ mod test {
     static INIT_AMOUNT: u128 = 500;
     static INIT_DENOM: &str = "TOKEN";
 
-    #[cfg(feature = "singlepass")]
-    use crate::backends::singlepass::GAS_LIMIT;
-    #[cfg(not(feature = "singlepass"))]
-    const GAS_LIMIT: u64 = 10_000_000_000;
+    const GAS_LIMIT: u64 = 5_000_000;
 
     fn make_instance() -> Box<WasmerInstance> {
         let module = compile(&CONTRACT).unwrap();

packages/vm/src/imports.rs

@@ -224,10 +224,7 @@ mod test {
     static INIT_AMOUNT: u128 = 500;
     static INIT_DENOM: &str = "TOKEN";
 
-    #[cfg(feature = "singlepass")]
-    use crate::backends::singlepass::GAS_LIMIT;
-    #[cfg(not(feature = "singlepass"))]
-    const GAS_LIMIT: u64 = 10_000_000_000;
+    const GAS_LIMIT: u64 = 5_000_000;
 
     fn make_instance() -> Box<WasmerInstance> {
         let module = compile(&CONTRACT).unwrap();