Merge branch 'master' into trace-print

mathetake · web-flow · commit 8bdd67da55d4 · 2020-10-27T20:04:05.000+09:00
diff --git a/BUILD b/BUILD
@@ -33,6 +33,7 @@ cc_library(
     copts = COPTS,
     deps = [
         ":include",
+        "@boringssl//:crypto",
         "@com_google_protobuf//:protobuf_lite",
         "@proxy_wasm_cpp_sdk//:api_lib",
     ],
diff --git a/CODEOWNERS b/CODEOWNERS
@@ -0,0 +1 @@
+* @PiotrSikora
diff --git a/WORKSPACE b/WORKSPACE
@@ -38,6 +38,13 @@ git_repository(
     shallow_since = "1565024848 -0700",
 )
 
+http_archive(
+    name = "boringssl",
+    sha256 = "bb55b0ed2f0cb548b5dce6a6b8307ce37f7f748eb9f1be6bfe2d266ff2b4d52b",
+    strip_prefix = "boringssl-2192bbc878822cf6ab5977d4257a1339453d9d39",
+    urls = ["https://github.com/google/boringssl/archive/2192bbc878822cf6ab5977d4257a1339453d9d39.tar.gz"],
+)
+
 http_archive(
     name = "com_google_googletest",
     sha256 = "9dc9157a9a1551ec7a7e43daea9a694a0bb5fb8bec81235d8a1e6ef64c716dcb",
diff --git a/include/proxy-wasm/exports.h b/include/proxy-wasm/exports.h
@@ -144,7 +144,8 @@ Word wasi_unstable_environ_sizes_get(void *raw_context, Word count_ptr, Word buf
 Word wasi_unstable_args_get(void *raw_context, Word argc_ptr, Word argv_buf_size_ptr);
 Word wasi_unstable_args_sizes_get(void *raw_context, Word argc_ptr, Word argv_buf_size_ptr);
 void wasi_unstable_proc_exit(void *, Word);
-void wasi_unstable_proc_exit(void *, Word);
+Word wasi_unstable_clock_time_get(void *, Word, uint64_t, Word);
+Word wasi_unstable_random_get(void *, Word, Word);
 Word pthread_equal(void *, Word left, Word right);
 
 // Support for embedders, not exported to Wasm.
diff --git a/include/proxy-wasm/wasm.h b/include/proxy-wasm/wasm.h
@@ -59,9 +59,7 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
   std::string_view vm_key() const { return vm_key_; }
   WasmVm *wasm_vm() const { return wasm_vm_.get(); }
   ContextBase *vm_context() const { return vm_context_.get(); }
-  ContextBase *getRootContext(std::string_view root_id) {
-    return root_contexts_[std::string(root_id)].get();
-  }
+  ContextBase *getRootContext(std::string_view root_id);
   ContextBase *getOrCreateRootContext(const std::shared_ptr<PluginBase> &plugin);
   ContextBase *getContext(uint32_t id) {
     auto it = contexts_.find(id);
@@ -124,20 +122,6 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
 
   AbiVersion abiVersion() { return abi_version_; }
 
-  bool getEmscriptenVersion(uint32_t *emscripten_metadata_major_version,
-                            uint32_t *emscripten_metadata_minor_version,
-                            uint32_t *emscripten_abi_major_version,
-                            uint32_t *emscripten_abi_minor_version) {
-    if (!is_emscripten_) {
-      return false;
-    }
-    *emscripten_metadata_major_version = emscripten_metadata_major_version_;
-    *emscripten_metadata_minor_version = emscripten_metadata_minor_version_;
-    *emscripten_abi_major_version = emscripten_abi_major_version_;
-    *emscripten_abi_minor_version = emscripten_abi_minor_version_;
-    return true;
-  }
-
   void addAfterVmCallAction(std::function<void()> f) { after_vm_call_actions_.push_back(f); }
   void doAfterVmCallActions() {
     // NB: this may be deleted by a delayed function unless prevented.
@@ -186,7 +170,8 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
   std::unique_ptr<ShutdownHandle> shutdown_handle_;
   std::unordered_set<ContextBase *> pending_done_; // Root contexts not done during shutdown.
 
-  WasmCallVoid<0> _start_; /* Emscripten v1.39.0+ */
+  WasmCallVoid<0> _initialize_; /* Emscripten v1.39.17+ */
+  WasmCallVoid<0> _start_;      /* Emscripten v1.39.0+ */
   WasmCallVoid<0> __wasm_call_ctors_;
 
   WasmCallWord<1> malloc_;
@@ -243,13 +228,6 @@ class WasmBase : public std::enable_shared_from_this<WasmBase> {
   // ABI version.
   AbiVersion abi_version_ = AbiVersion::Unknown;
 
-  bool is_emscripten_ = false;
-  uint32_t emscripten_metadata_major_version_ = 0;
-  uint32_t emscripten_metadata_minor_version_ = 0;
-  uint32_t emscripten_abi_major_version_ = 0;
-  uint32_t emscripten_abi_minor_version_ = 0;
-  uint32_t emscripten_standalone_wasm_ = 0;
-
   // Plugin Stats/Metrics
   uint32_t next_counter_metric_id_ = static_cast<uint32_t>(MetricType::Counter);
   uint32_t next_gauge_metric_id_ = static_cast<uint32_t>(MetricType::Gauge);
diff --git a/include/proxy-wasm/wasm_vm.h b/include/proxy-wasm/wasm_vm.h
@@ -17,8 +17,8 @@
 
 #include <functional>
 #include <memory>
-#include <string>
 #include <optional>
+#include <string>
 
 #include "include/proxy-wasm/word.h"
 
@@ -78,6 +78,7 @@ template <size_t N> using WasmCallbackWord = WasmFuncType<N, Word, void *, Word>
 using WasmCallback_WWl = Word (*)(void *, Word, int64_t);
 using WasmCallback_WWlWW = Word (*)(void *, Word, int64_t, Word, Word);
 using WasmCallback_WWm = Word (*)(void *, Word, uint64_t);
+using WasmCallback_WWmW = Word (*)(void *, Word, uint64_t, Word);
 using WasmCallback_dd = double (*)(void *, double);
 
 #define FOR_ALL_WASM_VM_IMPORTS(_f)                                                                \
@@ -94,7 +95,8 @@ using WasmCallback_dd = double (*)(void *, double);
                                           _f(proxy_wasm::WasmCallback_WWl)                         \
                                               _f(proxy_wasm::WasmCallback_WWlWW)                   \
                                                   _f(proxy_wasm::WasmCallback_WWm)                 \
-                                                      _f(proxy_wasm::WasmCallback_dd)
+                                                      _f(proxy_wasm::WasmCallback_WWmW)            \
+                                                          _f(proxy_wasm::WasmCallback_dd)
 
 enum class Cloneable {
   NotCloneable,      // VMs can not be cloned and should be created from scratch.
diff --git a/src/context.cc b/src/context.cc
@@ -331,9 +331,24 @@ bool ContextBase::onStart(std::shared_ptr<PluginBase> plugin) {
 }
 
 bool ContextBase::onConfigure(std::shared_ptr<PluginBase> plugin) {
-  if (isFailed() || !wasm_->on_configure_) {
+  if (isFailed()) {
     return true;
   }
+
+  // on_context_create is yet to be executed for all the root contexts except the first one
+  if (!in_vm_context_created_ && wasm_->on_context_create_) {
+    DeferAfterCallActions actions(this);
+    wasm_->on_context_create_(this, id_, 0);
+  }
+
+  // NB: If no on_context_create function is registered the in-VM SDK is responsible for
+  // managing any required in-VM state.
+  in_vm_context_created_ = true;
+
+  if (!wasm_->on_configure_) {
+    return true;
+  }
+
   DeferAfterCallActions actions(this);
   plugin_ = plugin;
   auto result =
diff --git a/src/exports.cc b/src/exports.cc
@@ -15,6 +15,8 @@
 //
 #include "include/proxy-wasm/wasm.h"
 
+#include <openssl/rand.h>
+
 #define WASM_CONTEXT(_c)                                                                           \
   (ContextOrEffectiveContext(static_cast<ContextBase *>((void)_c, current_context_)))
 
@@ -798,6 +800,33 @@ Word wasi_unstable_args_sizes_get(void *raw_context, Word argc_ptr, Word argv_bu
   return 0; // __WASI_ESUCCESS
 }
 
+// __wasi_errno_t __wasi_clock_time_get(uint32_t id, uint64_t precision, uint64_t* time);
+Word wasi_unstable_clock_time_get(void *raw_context, Word clock_id, uint64_t precision,
+                                  Word result_time_uint64_ptr) {
+
+  if (clock_id != 0 /* realtime */) {
+    return 58; // __WASI_ENOTSUP
+  }
+
+  auto context = WASM_CONTEXT(raw_context);
+  uint64_t result = context->getCurrentTimeNanoseconds();
+  if (!context->wasm()->setDatatype(result_time_uint64_ptr, result)) {
+    return 21; // __WASI_EFAULT
+  }
+  return 0; // __WASI_ESUCCESS
+}
+
+// __wasi_errno_t __wasi_random_get(uint8_t *buf, size_t buf_len);
+Word wasi_unstable_random_get(void *raw_context, Word result_buf_ptr, Word buf_len) {
+  auto context = WASM_CONTEXT(raw_context);
+  std::vector<uint8_t> random(buf_len);
+  RAND_bytes(random.data(), random.size());
+  if (!context->wasmVm()->setMemory(result_buf_ptr, random.size(), random.data())) {
+    return 21; // __WASI_EFAULT
+  }
+  return 0; // __WASI_ESUCCESS
+}
+
 // void __wasi_proc_exit(__wasi_exitcode_t rval);
 void wasi_unstable_proc_exit(void *raw_context, Word) {
   auto context = WASM_CONTEXT(raw_context);
diff --git a/src/null/null_plugin.cc b/src/null/null_plugin.cc
@@ -33,7 +33,9 @@
 namespace proxy_wasm {
 
 void NullPlugin::getFunction(std::string_view function_name, WasmCallVoid<0> *f) {
-  if (function_name == "_start") {
+  if (function_name == "_initialize") {
+    *f = nullptr;
+  } else if (function_name == "_start") {
     *f = nullptr;
   } else if (function_name == "__wasm_call_ctors") {
     *f = nullptr;
diff --git a/src/v8/v8.cc b/src/v8/v8.cc
@@ -616,10 +616,15 @@ void V8::getModuleFunctionImpl(std::string_view function_name,
     return;
   }
   const wasm::Func *func = it->second.get();
-  if (!equalValTypes(func->type()->params(), convertArgsTupleToValTypes<std::tuple<Args...>>()) ||
-      !equalValTypes(func->type()->results(), convertArgsTupleToValTypes<std::tuple<>>())) {
+  auto arg_valtypes = convertArgsTupleToValTypes<std::tuple<Args...>>();
+  auto result_valtypes = convertArgsTupleToValTypes<std::tuple<>>();
+  if (!equalValTypes(func->type()->params(), arg_valtypes) ||
+      !equalValTypes(func->type()->results(), result_valtypes)) {
     fail(FailState::UnableToInitializeCode,
-         std::string("Bad function signature for: ") + std::string(function_name));
+         "Bad function signature for: " + std::string(function_name) +
+             ", want: " + printValTypes(arg_valtypes) + " -> " + printValTypes(result_valtypes) +
+             ", but the module exports: " + printValTypes(func->type()->params()) + " -> " +
+             printValTypes(result_valtypes));
     *function = nullptr;
     return;
   }
@@ -643,10 +648,15 @@ void V8::getModuleFunctionImpl(std::string_view function_name,
     return;
   }
   const wasm::Func *func = it->second.get();
-  if (!equalValTypes(func->type()->params(), convertArgsTupleToValTypes<std::tuple<Args...>>()) ||
-      !equalValTypes(func->type()->results(), convertArgsTupleToValTypes<std::tuple<R>>())) {
+  auto arg_valtypes = convertArgsTupleToValTypes<std::tuple<Args...>>();
+  auto result_valtypes = convertArgsTupleToValTypes<std::tuple<R>>();
+  if (!equalValTypes(func->type()->params(), arg_valtypes) ||
+      !equalValTypes(func->type()->results(), result_valtypes)) {
     fail(FailState::UnableToInitializeCode,
-         "Bad function signature for: " + std::string(function_name));
+         "Bad function signature for: " + std::string(function_name) +
+             ", want: " + printValTypes(arg_valtypes) + " -> " + printValTypes(result_valtypes) +
+             ", but the module exports: " + printValTypes(func->type()->params()) + " -> " +
+             printValTypes(result_valtypes));
     *function = nullptr;
     return;
   }
diff --git a/src/wasm.cc b/src/wasm.cc
@@ -44,22 +44,6 @@ std::unordered_map<std::string, WasmForeignFunction> *foreign_functions = nullpt
 
 const std::string INLINE_STRING = "<inline>";
 
-const uint8_t *decodeVarint(const uint8_t *pos, const uint8_t *end, uint32_t *out) {
-  uint32_t ret = 0;
-  int shift = 0;
-  while (pos < end && (*pos & 0x80)) {
-    ret |= (*pos & 0x7f) << shift;
-    shift += 7;
-    pos++;
-  }
-  if (pos < end) {
-    ret |= *pos << shift;
-    pos++;
-  }
-  *out = ret;
-  return pos;
-}
-
 std::string Sha256(std::string_view data) {
   std::vector<unsigned char> hash(picosha2::k_digest_size);
   picosha2::hash256(data.begin(), data.end(), hash.begin(), hash.end());
@@ -131,6 +115,8 @@ void WasmBase::registerCallbacks() {
   _REGISTER_WASI(environ_sizes_get);
   _REGISTER_WASI(args_get);
   _REGISTER_WASI(args_sizes_get);
+  _REGISTER_WASI(clock_time_get);
+  _REGISTER_WASI(random_get);
   _REGISTER_WASI(proc_exit);
 #undef _REGISTER_WASI
 
@@ -207,13 +193,19 @@ void WasmBase::registerCallbacks() {
 
 void WasmBase::getFunctions() {
 #define _GET(_fn) wasm_vm_->getFunction(#_fn, &_fn##_);
+#define _GET_ALIAS(_fn, _alias) wasm_vm_->getFunction(#_alias, &_fn##_);
+  _GET(_initialize);
   _GET(_start);
   _GET(__wasm_call_ctors);
 
   _GET(malloc);
+  if (!malloc_) {
+    _GET_ALIAS(malloc, proxy_on_memory_allocate);
+  }
   if (!malloc_) {
     fail(FailState::MissingFunction, "Wasm module is missing malloc function.");
   }
+#undef _GET_ALIAS
 #undef _GET
 
 #define _GET_PROXY(_fn) wasm_vm_->getFunction("proxy_" #_fn, &_fn##_);
@@ -300,36 +292,6 @@ bool WasmBase::initialize(const std::string &code, bool allow_precompiled) {
     if (!ok) {
       return false;
     }
-    auto metadata = wasm_vm_->getCustomSection("emscripten_metadata");
-    if (!metadata.empty()) {
-      // See https://github.com/emscripten-core/emscripten/blob/incoming/tools/shared.py#L3059
-      is_emscripten_ = true;
-      auto start = reinterpret_cast<const uint8_t *>(metadata.data());
-      auto end = reinterpret_cast<const uint8_t *>(metadata.data() + metadata.size());
-      start = decodeVarint(start, end, &emscripten_metadata_major_version_);
-      start = decodeVarint(start, end, &emscripten_metadata_minor_version_);
-      start = decodeVarint(start, end, &emscripten_abi_major_version_);
-      start = decodeVarint(start, end, &emscripten_abi_minor_version_);
-      uint32_t temp;
-      if (emscripten_metadata_major_version_ > 0 || emscripten_metadata_minor_version_ > 1) {
-        // metadata 0.2 - added: wasm_backend.
-        start = decodeVarint(start, end, &temp);
-      }
-      start = decodeVarint(start, end, &temp);
-      start = decodeVarint(start, end, &temp);
-      if (emscripten_metadata_major_version_ > 0 || emscripten_metadata_minor_version_ > 0) {
-        // metadata 0.1 - added: global_base, dynamic_base, dynamictop_ptr and tempdouble_ptr.
-        start = decodeVarint(start, end, &temp);
-        start = decodeVarint(start, end, &temp);
-        start = decodeVarint(start, end, &temp);
-        decodeVarint(start, end, &temp);
-        if (emscripten_metadata_major_version_ > 0 || emscripten_metadata_minor_version_ > 2) {
-          // metadata 0.3 - added: standalone_wasm.
-          start = decodeVarint(start, end, &emscripten_standalone_wasm_);
-        }
-      }
-    }
-
     code_ = code;
     allow_precompiled_ = allow_precompiled;
   }
@@ -357,6 +319,14 @@ bool WasmBase::initialize(const std::string &code, bool allow_precompiled) {
   return !isFailed();
 }
 
+ContextBase *WasmBase::getRootContext(std::string_view root_id) {
+  auto it = root_contexts_.find(std::string(root_id));
+  if (it == root_contexts_.end()) {
+    return nullptr;
+  }
+  return it->second.get();
+}
+
 ContextBase *WasmBase::getOrCreateRootContext(const std::shared_ptr<PluginBase> &plugin) {
   auto root_context = getRootContext(plugin->root_id_);
   if (!root_context) {
@@ -368,8 +338,9 @@ ContextBase *WasmBase::getOrCreateRootContext(const std::shared_ptr<PluginBase>
 }
 
 void WasmBase::startVm(ContextBase *root_context) {
-  /* Call "_start" function, and fallback to "__wasm_call_ctors" if the former is not available. */
-  if (_start_) {
+  if (_initialize_) {
+    _initialize_(root_context);
+  } else if (_start_) {
     _start_(root_context);
   } else if (__wasm_call_ctors_) {
     __wasm_call_ctors_(root_context);
diff --git a/src/wavm/wavm.cc b/src/wavm/wavm.cc
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 #include "include/proxy-wasm/wavm.h"
+#include "include/proxy-wasm/wasm_vm.h"
 
 #include <cstdlib>
 #include <iostream>
@@ -24,8 +25,6 @@
 #include <utility>
 #include <vector>
 
-#include "include/proxy-wasm/wasm_vm.h"
-
 #include "WAVM/IR/Module.h"
 #include "WAVM/IR/Operators.h"
 #include "WAVM/IR/Types.h"
@@ -253,6 +252,8 @@ Wavm::~Wavm() {
 
 std::unique_ptr<WasmVm> Wavm::clone() {
   auto wavm = std::make_unique<Wavm>();
+  wavm->integration().reset(integration()->clone());
+
   wavm->compartment_ = WAVM::Runtime::cloneCompartment(compartment_);
   wavm->memory_ = WAVM::Runtime::remapToClonedCompartment(memory_, wavm->compartment_);
   wavm->memory_base_ = WAVM::Runtime::getMemoryBaseAddress(wavm->memory_);
