n-api: emit uncaught-exception on unhandled tsfn callbacks

nodejs · Jan 14, 2021 · f156f87 · f156f87
1 parent 2ba8728
commit f156f87
Show file tree

Hide file tree

Showing 9 changed files with 211 additions and 35 deletions.
diff --git a/src/js_native_api_v8.h b/src/js_native_api_v8.h
@@ -101,11 +101,26 @@ struct napi_env__ {
     }
   }
 
+  template <typename T>
+  inline void CallbackIntoModule(T&& call) {
+    CallIntoModule(call, [](napi_env env, v8::Local<v8::Value> local_err) {
+      // If there was an unhandled exception in the complete callback,
+      // report it as a fatal exception. (There is no JavaScript on the
+      // callstack that can possibly handle it.)
+      v8impl::trigger_fatal_exception(env, local_err);
+    });
+  }
+
   virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) {
     v8::HandleScope handle_scope(isolate);
-    CallIntoModule([&](napi_env env) {
-      cb(env, data, hint);
-    });
+    CallIntoModule([&](napi_env env) { cb(env, data, hint); },
+                   [](napi_env env, v8::Local<v8::Value> local_err) {
+                     // If there was an unhandled exception in the complete
+                     // callback, report it as a fatal exception. (There is no
+                     // JavaScript on the callstack that can possibly handle
+                     // it.)
+                     v8impl::trigger_fatal_exception(env, local_err);
+                   });
   }
 
   v8impl::Persistent<v8::Value> last_exception;

diff --git a/src/js_native_api_v8_internals.h b/src/js_native_api_v8_internals.h
@@ -33,6 +33,8 @@ using Persistent = v8::Global<T>;
 
 using PersistentToLocal = node::PersistentToLocal;
 
+void trigger_fatal_exception(napi_env env, v8::Local<v8::Value> local_err);
+
 }  // end of namespace v8impl
 
 #endif  // SRC_JS_NATIVE_API_V8_INTERNALS_H_
diff --git a/src/node_api.cc b/src/node_api.cc
@@ -38,20 +38,22 @@ struct node_napi_env__ : public napi_env__ {
 
   void CallFinalizer(napi_finalize cb, void* data, void* hint) override {
     napi_env env = static_cast<napi_env>(this);
-    node_env()->SetImmediate([=](node::Environment* node_env) {
-      v8::HandleScope handle_scope(env->isolate);
-      v8::Context::Scope context_scope(env->context());
-      env->CallIntoModule([&](napi_env env) {
-        cb(env, data, hint);
-      });
-    });
+    v8::HandleScope handle_scope(env->isolate);
+    v8::Context::Scope context_scope(env->context());
+    (napi_env__::CallFinalizer)(cb, data, hint);
   }
 };
 
 typedef node_napi_env__* node_napi_env;
 
 namespace v8impl {
 
+void trigger_fatal_exception(napi_env env, v8::Local<v8::Value> local_err) {
+  v8::Local<v8::Message> local_msg =
+      v8::Exception::CreateMessage(env->isolate, local_err);
+  node::errors::TriggerUncaughtException(env->isolate, local_err, local_msg);
+}
+
 namespace {
 
 class BufferFinalizer : private Finalizer {
@@ -71,12 +73,9 @@ class BufferFinalizer : private Finalizer {
       v8::HandleScope handle_scope(finalizer->_env->isolate);
       v8::Context::Scope context_scope(finalizer->_env->context());
 
-      finalizer->_env->CallIntoModule([&](napi_env env) {
-        finalizer->_finalize_callback(
-            env,
-            finalizer->_finalize_data,
-            finalizer->_finalize_hint);
-      });
+      finalizer->_env->CallFinalizer(finalizer->_finalize_callback,
+                                     finalizer->_finalize_data,
+                                     finalizer->_finalize_hint);
     });
   }
 
@@ -107,13 +106,6 @@ static inline napi_env NewEnv(v8::Local<v8::Context> context) {
   return result;
 }
 
-static inline void trigger_fatal_exception(
-    napi_env env, v8::Local<v8::Value> local_err) {
-  v8::Local<v8::Message> local_msg =
-    v8::Exception::CreateMessage(env->isolate, local_err);
-  node::errors::TriggerUncaughtException(env->isolate, local_err, local_msg);
-}
-
 class ThreadSafeFunction : public node::AsyncResource {
  public:
   ThreadSafeFunction(v8::Local<v8::Function> func,
@@ -312,19 +304,17 @@ class ThreadSafeFunction : public node::AsyncResource {
           v8::Local<v8::Function>::New(env->isolate, ref);
         js_callback = v8impl::JsValueFromV8LocalValue(js_cb);
       }
-      env->CallIntoModule([&](napi_env env) {
-        call_js_cb(env, js_callback, context, data);
-      });
+      env->CallbackIntoModule(
+          [&](napi_env env) { call_js_cb(env, js_callback, context, data); });
     }
   }
 
   void Finalize() {
     v8::HandleScope scope(env->isolate);
     if (finalize_cb) {
       CallbackScope cb_scope(this);
-      env->CallIntoModule([&](napi_env env) {
-        finalize_cb(env, finalize_data, context);
-      });
+      env->CallbackIntoModule(
+          [&](napi_env env) { finalize_cb(env, finalize_data, context); });
     }
     EmptyQueueAndDelete();
   }
@@ -1043,13 +1033,8 @@ class Work : public node::AsyncResource, public node::ThreadPoolWork {
 
     CallbackScope callback_scope(this);
 
-    _env->CallIntoModule([&](napi_env env) {
+    _env->CallbackIntoModule([&](napi_env env) {
       _complete(env, ConvertUVErrorCode(status), _data);
-    }, [](napi_env env, v8::Local<v8::Value> local_err) {
-      // If there was an unhandled exception in the complete callback,
-      // report it as a fatal exception. (There is no JavaScript on the
-      // callstack that can possibly handle it.)
-      v8impl::trigger_fatal_exception(env, local_err);
     });
 
     // Note: Don't access `work` after this point because it was

diff --git a/test/js-native-api/test_reference/test_finalizer.js b/test/js-native-api/test_reference/test_finalizer.js
@@ -0,0 +1,20 @@
+'use strict';
+// Flags: --expose-gc --no-concurrent-array-buffer-freeing --no-concurrent-array-buffer-sweeping
+
+const common = require('../../common');
+const test_reference = require(`./build/${common.buildType}/test_reference`);
+const assert = require('assert');
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.throws(() => { throw err; }, /finalizer error/);
+}));
+
+(async function() {
+  {
+    test_reference.createExternalWithJsFinalize(
+      common.mustCall(() => {
+        throw new Error('finalizer error');
+      }));
+  }
+  global.gc();
+})().then(common.mustCall());
diff --git a/test/js-native-api/test_reference/test_reference.c b/test/js-native-api/test_reference/test_reference.c
@@ -20,6 +20,20 @@ static void FinalizeExternal(napi_env env, void* data, void* hint) {
   finalize_count++;
 }
 
+static void FinalizeExternalCallJs(napi_env env, void* data, void* hint) {
+  int *actual_value = data;
+  NAPI_ASSERT_RETURN_VOID(env, actual_value == &test_value,
+      "The correct pointer was passed to the finalizer");
+
+  napi_ref finalizer_ref = (napi_ref)hint;
+  napi_value js_finalizer;
+  napi_value recv;
+  NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, finalizer_ref, &js_finalizer));
+  NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &recv));
+  NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, js_finalizer, 0, NULL, NULL));
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, finalizer_ref));
+}
+
 static napi_value CreateExternal(napi_env env, napi_callback_info info) {
   int* data = &test_value;
 
@@ -49,6 +63,31 @@ CreateExternalWithFinalize(napi_env env, napi_callback_info info) {
   return result;
 }
 
+static napi_value
+CreateExternalWithJsFinalize(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value finalizer = args[0];
+  napi_valuetype finalizer_valuetype;
+  NAPI_CALL(env, napi_typeof(env, finalizer, &finalizer_valuetype));
+  NAPI_ASSERT(env, finalizer_valuetype == napi_function, "Wrong type of first argument");
+  napi_ref finalizer_ref;
+  NAPI_CALL(env, napi_create_reference(env, finalizer, 1, &finalizer_ref));
+
+  napi_value result;
+  NAPI_CALL(env,
+      napi_create_external(env,
+                           &test_value,
+                           FinalizeExternalCallJs,
+                           finalizer_ref, /* finalize_hint */
+                           &result));
+
+  finalize_count = 0;
+  return result;
+}
+
 static napi_value CheckExternal(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value arg;
@@ -176,6 +215,8 @@ napi_value Init(napi_env env, napi_value exports) {
     DECLARE_NAPI_PROPERTY("createExternal", CreateExternal),
     DECLARE_NAPI_PROPERTY("createExternalWithFinalize",
         CreateExternalWithFinalize),
+    DECLARE_NAPI_PROPERTY("createExternalWithJsFinalize",
+        CreateExternalWithJsFinalize),
     DECLARE_NAPI_PROPERTY("checkExternal", CheckExternal),
     DECLARE_NAPI_PROPERTY("createReference", CreateReference),
     DECLARE_NAPI_PROPERTY("deleteReference", DeleteReference),

diff --git a/test/node-api/test_buffer/test_buffer.c b/test/node-api/test_buffer/test_buffer.c
@@ -20,6 +20,17 @@ static void noopDeleter(napi_env env, void* data, void* finalize_hint) {
   deleterCallCount++;
 }
 
+static void malignDeleter(napi_env env, void* data, void* finalize_hint) {
+  NAPI_ASSERT_RETURN_VOID(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
+  napi_ref finalizer_ref = (napi_ref)finalize_hint;
+  napi_value js_finalizer;
+  napi_value recv;
+  NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, finalizer_ref, &js_finalizer));
+  NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &recv));
+  NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, js_finalizer, 0, NULL, NULL));
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, finalizer_ref));
+}
+
 static napi_value newBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   char* theCopy;
@@ -119,6 +130,30 @@ static napi_value staticBuffer(napi_env env, napi_callback_info info) {
   return theBuffer;
 }
 
+static napi_value malignFinalizerBuffer(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value finalizer = args[0];
+  napi_valuetype finalizer_valuetype;
+  NAPI_CALL(env, napi_typeof(env, finalizer, &finalizer_valuetype));
+  NAPI_ASSERT(env, finalizer_valuetype == napi_function, "Wrong type of first argument");
+  napi_ref finalizer_ref;
+  NAPI_CALL(env, napi_create_reference(env, finalizer, 1, &finalizer_ref));
+
+  napi_value theBuffer;
+  NAPI_CALL(
+      env,
+      napi_create_external_buffer(env,
+                                  sizeof(theText),
+                                  (void*)theText,
+                                  malignDeleter,
+                                  finalizer_ref,  // finalize_hint
+                                  &theBuffer));
+  return theBuffer;
+}
+
 static napi_value Init(napi_env env, napi_value exports) {
   napi_value theValue;
 
@@ -134,6 +169,7 @@ static napi_value Init(napi_env env, napi_value exports) {
     DECLARE_NAPI_PROPERTY("bufferHasInstance", bufferHasInstance),
     DECLARE_NAPI_PROPERTY("bufferInfo", bufferInfo),
     DECLARE_NAPI_PROPERTY("staticBuffer", staticBuffer),
+    DECLARE_NAPI_PROPERTY("malignFinalizerBuffer", malignFinalizerBuffer),
   };
 
   NAPI_CALL(env, napi_define_properties(

diff --git a/test/node-api/test_buffer/test_finalizer.js b/test/node-api/test_buffer/test_finalizer.js
@@ -0,0 +1,21 @@
+'use strict';
+// Flags: --expose-gc --no-concurrent-array-buffer-freeing --no-concurrent-array-buffer-sweeping
+
+const common = require('../../common');
+const binding = require(`./build/${common.buildType}/test_buffer`);
+const assert = require('assert');
+const tick = require('util').promisify(require('../../common/tick'));
+
+process.on('uncaughtException', common.mustCall((err) => {
+  assert.throws(() => { throw err; }, /finalizer error/);
+}));
+
+(async function() {
+  {
+    binding.malignFinalizerBuffer(common.mustCall(() => {
+      throw new Error('finalizer error');
+    }));
+  }
+  global.gc();
+  await tick(10);
+})().then(common.mustCall());
diff --git a/test/node-api/test_threadsafe_function/binding.c b/test/node-api/test_threadsafe_function/binding.c
@@ -267,6 +267,35 @@ static napi_value StartThreadNoJsFunc(napi_env env, napi_callback_info info) {
     /** block_on_full */true, /** alt_ref_js_cb */true);
 }
 
+// Testing calling into JavaScript
+static void ThreadSafeFunctionFinalize(napi_env env,
+                              void* finalize_data,
+                              void* finalize_hint) {
+  napi_ref js_func_ref = (napi_ref) finalize_data;
+  napi_value js_func;
+  napi_value recv;
+  NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, js_func_ref, &js_func));
+  NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &recv));
+  NAPI_CALL_RETURN_VOID(env, napi_call_function(env, recv, js_func, 0, NULL, NULL));
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, js_func_ref));
+}
+
+// Testing calling into JavaScript
+static napi_value CallIntoModule(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value argv[4];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+  napi_ref finalize_func;
+  NAPI_CALL(env, napi_create_reference(env, argv[3], 1, &finalize_func));
+
+  napi_threadsafe_function tsfn;
+  NAPI_CALL(env, napi_create_threadsafe_function(env, argv[0], argv[1], argv[2], 0, 1, finalize_func, ThreadSafeFunctionFinalize, NULL, NULL, &tsfn));
+  NAPI_CALL(env, napi_call_threadsafe_function(tsfn, NULL, napi_tsfn_blocking));
+  NAPI_CALL(env, napi_release_threadsafe_function(tsfn, napi_tsfn_release));
+  return NULL;
+}
+
 // Module init
 static napi_value Init(napi_env env, napi_value exports) {
   size_t index;
@@ -305,6 +334,7 @@ static napi_value Init(napi_env env, napi_value exports) {
     DECLARE_NAPI_PROPERTY("StopThread", StopThread),
     DECLARE_NAPI_PROPERTY("Unref", Unref),
     DECLARE_NAPI_PROPERTY("Release", Release),
+    DECLARE_NAPI_PROPERTY("CallIntoModule", CallIntoModule),
   };
 
   NAPI_CALL(env, napi_define_properties(env, exports,

diff --git a/test/node-api/test_threadsafe_function/test_uncaught_exception.js b/test/node-api/test_threadsafe_function/test_uncaught_exception.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+const callbackCheck = common.mustCall((err) => {
+  assert.throws(() => { throw err; }, /callback error/);
+  process.removeListener('uncaughtException', callbackCheck);
+  process.on('uncaughtException', finalizerCheck);
+});
+const finalizerCheck = common.mustCall((err) => {
+  assert.throws(() => { throw err; }, /finalizer error/);
+});
+process.on('uncaughtException', callbackCheck);
+
+binding.CallIntoModule(
+  common.mustCall(() => {
+    throw new Error('callback error');
+  }),
+  {},
+  'resource_name',
+  common.mustCall(function finalizer() {
+    throw new Error('finalizer error');
+  })
+);