Add terminate execution API.

include/proxy-wasm/wasm.h

@@ -85,7 +85,6 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
 
   void timerReady(uint32_t root_context_id);
   void queueReady(uint32_t root_context_id, uint32_t token);
-
   void startShutdown(std::string_view plugin_key);
   void startShutdown();
   WasmResult done(ContextBase *root_context);

include/proxy-wasm/wasm_vm.h

@@ -311,6 +311,7 @@ class WasmVm {
 
   // Integrator operations.
   std::unique_ptr<WasmVmIntegration> &integration() { return integration_; }
+  virtual void terminateExecution() {}
   bool cmpLogLevel(proxy_wasm::LogLevel level) { return integration_->getLogLevel() <= level; }
 
 protected:

src/v8/v8.cc

@@ -21,12 +21,14 @@
 #include <mutex>
 #include <optional>
 #include <sstream>
+#include <thread>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "include/v8-version.h"
 #include "include/v8.h"
+#include "src/wasm/c-api.h"
 #include "wasm-api/wasm.hh"
 
 namespace proxy_wasm {
@@ -66,6 +68,14 @@ class V8 : public WasmVm {
             const std::unordered_map<uint32_t, std::string> &function_names) override;
   std::string_view getPrecompiledSectionName() override;
   bool link(std::string_view debug_name) override;
+  void terminateExecution() override {
+    auto *store_impl = reinterpret_cast<wasm::StoreImpl *>(store_.get());
+    auto *isolate = store_impl->isolate();
+    isolate->TerminateExecution();
+    while (isolate->IsExecutionTerminating()) {
+      std::this_thread::yield();
+    }
+  }
 
   Cloneable cloneable() override { return Cloneable::CompiledBytecode; }
   std::unique_ptr<WasmVm> clone() override;

test/runtime_test.cc

@@ -14,11 +14,13 @@
 
 #include "gtest/gtest.h"
 
+#include <cassert>
 #include <fstream>
 #include <iostream>
 #include <memory>
 #include <sstream>
 #include <string>
+#include <thread>
 #include <vector>
 
 #include "include/proxy-wasm/context.h"
@@ -245,6 +247,40 @@ TEST_P(TestVM, Callback) {
   ASSERT_EQ(res.u32(), 100100); // 10000 (global) + 100(in callback)
 }
 
+TEST_P(TestVM, TerminateExecution) {
+  if (engine_ != "v8") {
+    return;
+  }
+  auto source = readTestWasmFile("callback.wasm");
+  ASSERT_TRUE(vm_->load(source, {}, {}));
+
+  TestContext context;
+  vm_->registerCallback(
+      "env", "callback", &callback,
+      &ConvertFunctionWordToUint32<decltype(callback), callback>::convertFunctionWordToUint32);
+
+  vm_->registerCallback(
+      "env", "callback2", &callback2,
+      &ConvertFunctionWordToUint32<decltype(callback2), callback2>::convertFunctionWordToUint32);
+
+  std::thread terminate([&]() {
+    std::this_thread::sleep_for(std::chrono::seconds(3));
+    vm_->terminateExecution();
+  });
+
+  ASSERT_TRUE(vm_->link(""));
+  WasmCallWord<1> run2;
+  vm_->getFunction("infinite_loop", &run2);
+  EXPECT_TRUE(run2 != nullptr);
+
+  run2(&context, Word{0});
+  terminate.join();
+
+  std::string exp_message = "Function: infinite_loop failed: Uncaught Error: termination_exception";
+  auto *integration = dynamic_cast<DummyIntegration *>(vm_->integration().get());
+  ASSERT_TRUE(integration->error_message_.find(exp_message) != std::string::npos);
+}
+
 TEST_P(TestVM, Trap) {
   auto source = readTestWasmFile("trap.wasm");
   ASSERT_TRUE(vm_->load(source, {}, {}));

test/test_data/callback.rs

@@ -28,6 +28,23 @@ pub extern "C" fn run2(val: i32) -> i32 {
     }
 }
 
+#[no_mangle]
+pub extern "C" fn infinite_loop(val: i32) -> i32 {
+    let mut count = val;
+    loop {
+        count += 1;
+        if count >= 10 {
+            count -= 2;
+        }
+        if count >= 100 {
+            break;
+        }
+    }
+    unsafe {
+        callback2(val) + A
+    }
+}
+
 extern "C" {
     fn callback();
     fn callback2(val: i32) -> i32;