async_wrap: print msg on error instead of abort

trevnorris · trevnorris · commit 79b11ceb6d28 · 2017-01-31T23:11:31.000-07:00
Print an error message when the stack is corrupted by the user. Use
DumpBacktrace() to show where in the native stack the error occurred.
Since it's likely that there will be no stack when this check is hit.
diff --git a/lib/async_hooks.js b/lib/async_hooks.js
@@ -54,7 +54,8 @@ const { kInit, kBefore, kAfter, kDestroy, kActiveHooks, kIdStackIndex,
 async_wrap.setupHooks({ init,
                         before: emitBeforeN,
                         after: emitAfterN,
-                        destroy: emitDestroyFromNative });
+                        destroy: emitDestroyFromNative,
+                        fatalError });
 
 // Used to fatally abort the process if a callback throws.
 function fatalError(e) {
diff --git a/src/async-wrap.cc b/src/async-wrap.cc
@@ -138,16 +138,21 @@ static void SetupHooks(const FunctionCallbackInfo<Value>& args) {
   Local<Value> destroy_v = fn_obj->Get(
       env->context(),
       FIXED_ONE_BYTE_STRING(env->isolate(), "destroy")).ToLocalChecked();
+  Local<Value> fatal_error_v = fn_obj->Get(
+      env->context(),
+      FIXED_ONE_BYTE_STRING(env->isolate(), "fatalError")).ToLocalChecked();
 
   CHECK(init_v->IsFunction());
   CHECK(before_v->IsFunction());
   CHECK(after_v->IsFunction());
   CHECK(destroy_v->IsFunction());
+  CHECK(fatal_error_v->IsFunction());
 
   env->set_async_hooks_init_function(init_v.As<Function>());
   env->set_async_hooks_before_function(before_v.As<Function>());
   env->set_async_hooks_after_function(after_v.As<Function>());
   env->set_async_hooks_destroy_function(destroy_v.As<Function>());
+  env->set_async_hooks_fatal_error_function(fatal_error_v.As<Function>());
 }
 
 
diff --git a/src/env-inl.h b/src/env-inl.h
@@ -147,7 +147,26 @@ inline void Environment::AsyncHooks::pop_from_id_stack(double id) {
   }
 
   // Make sure the stack hasn't become corrupted.
-  CHECK_EQ(id_stack_[fields_[AsyncHooks::kIdStackIndex]], id);
+  if (id_stack_[fields_[AsyncHooks::kIdStackIndex]] != id) {
+    DumpBacktrace(stderr);
+    fprintf(stderr, "\n");
+    fflush(stderr);
+    // message + 2 * max number length) + 1
+    char msg[77] = {};
+    snprintf(msg,
+             77,
+             "async hook stack has become corrupted: %'.f %'.f",
+             id_stack_[fields_[AsyncHooks::kIdStackIndex]],
+             id);
+    Environment* env = Environment::GetCurrent(isolate_);
+    v8::HandleScope handle_scope(isolate_);
+    v8::Local<v8::Function> fn = env->async_hooks_fatal_error_function();
+    v8::Local<v8::Value> argv =
+      FIXED_ONE_BYTE_STRING(isolate_, msg);
+    fn->Call(env->context(), v8::Undefined(isolate_), 1, &argv)
+      .ToLocalChecked();
+    CHECK(false && "UNREACHABLE");
+  }
 
   // Fast path where there's probably no extra stack.
   if (fields_[AsyncHooks::kIdStackSize] < AsyncHooks::kIdStackLimit) {
diff --git a/src/env.h b/src/env.h
@@ -233,6 +233,7 @@ namespace node {
   V(async_hooks_destroy_function, v8::Function)                               \
   V(async_hooks_init_function, v8::Function)                                  \
   V(async_hooks_before_function, v8::Function)                                \
+  V(async_hooks_fatal_error_function, v8::Function)                           \
   V(async_hooks_after_function, v8::Function)                                 \
   V(binding_cache_object, v8::Object)                                         \
   V(buffer_constructor_function, v8::Function)                                \
