report: print javascript stack on fatal error

Try to print JavaScript stack on fatal error. OOMError needs to be
distinguished from fatal error since no new handle can be created at
that time.
PR-URL: #44242
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Michael Dawson <midawson@redhat.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>

Author: legendecas

src/api/environment.cc

@@ -239,6 +239,7 @@ void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s) {
 auto* fatal_error_cb = s.fatal_error_callback ?
  s.fatal_error_callback : OnFatalError;
  isolate->SetFatalErrorHandler(fatal_error_cb);
+ isolate->SetOOMErrorHandler(OOMErrorHandler);
 
 if ((s.flags & SHOULD_NOT_SET_PREPARE_STACK_TRACE_CALLBACK) == 0) {
 auto* prepare_stack_trace_cb = s.prepare_stack_trace_callback ?

src/node_errors.cc

@@ -501,6 +501,36 @@ void OnFatalError(const char* location, const char* message) {
 ABORT();
 }
 
+voidOOMErrorHandler(constchar* location, bool is_heap_oom) {
+constchar* message =
+ is_heap_oom ? "Allocation failed - JavaScript heap out of memory"
+ : "Allocation failed - process out of memory";
+if (location) {
+FPrintF(stderr, "FATAL ERROR: %s %s\n", location, message);
+ } else {
+FPrintF(stderr, "FATAL ERROR: %s\n", message);
+ }
+
+ Isolate* isolate = Isolate::TryGetCurrent();
+ Environment* env = nullptr;
+if (isolate != nullptr) {
+ env = Environment::GetCurrent(isolate);
+ }
+bool report_on_fatalerror;
+ {
+ Mutex::ScopedLock lock(node::per_process::cli_options_mutex);
+ report_on_fatalerror = per_process::cli_options->report_on_fatalerror;
+ }
+
+if (report_on_fatalerror) {
+report::TriggerNodeReport(
+ isolate, env, message, "OOMError", "", Local<Object>());
+ }
+
+fflush(stderr);
+ABORT();
+}
+
 v8::ModifyCodeGenerationFromStringsResult ModifyCodeGenerationFromStrings(
  v8::Local<v8::Context> context,
  v8::Local<v8::Value> source,

src/node_errors.h

@@ -21,6 +21,7 @@ void AppendExceptionLine(Environment* env,
 
 [[noreturn]]voidFatalError(constchar* location, constchar* message);
 voidOnFatalError(constchar* location, constchar* message);
+voidOOMErrorHandler(constchar* location, bool is_heap_oom);
 
 // Helpers to construct errors similar to the ones provided by
 // lib/internal/errors.js.

src/node_report.cc

@@ -26,6 +26,7 @@
 constexprintNODE_REPORT_VERSION = 2;
 constexprintNANOS_PER_SEC = 1000 * 1000 * 1000;
 constexprdoubleSEC_PER_MICROS = 1e-6;
+constexprintMAX_FRAME_COUNT = 10;
 
 namespacenode {
 namespacereport {
@@ -43,6 +44,10 @@ using v8::Maybe;
 using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
+using v8::RegisterState;
+using v8::SampleInfo;
+using v8::StackFrame;
+using v8::StackTrace;
 using v8::String;
 using v8::TryCatch;
 using v8::V8;
@@ -62,6 +67,9 @@ static void PrintJavaScriptErrorStack(JSONWriter* writer,
  Isolate* isolate,
  Local<Value> error,
 constchar* trigger);
+staticvoidPrintJavaScriptStack(JSONWriter* writer,
+ Isolate* isolate,
+constchar* trigger);
 staticvoidPrintJavaScriptErrorProperties(JSONWriter* writer,
  Isolate* isolate,
  Local<Value> error);
@@ -269,8 +277,6 @@ static void WriteNodeReport(Isolate* isolate,
 // Report summary JavaScript error stack backtrace
 PrintJavaScriptErrorStack(&writer, isolate, error, trigger);
 
-// Report summary JavaScript error properties backtrace
-PrintJavaScriptErrorProperties(&writer, isolate, error);
  writer.json_objectend(); // the end of 'javascriptStack'
 
 // Report V8 Heap and Garbage Collector information
@@ -317,7 +323,7 @@ static void WriteNodeReport(Isolate* isolate,
  env,
 "Worker thread subreport",
  trigger,
- Local<Object>(),
+ Local<Value>(),
  os);
 
  Mutex::ScopedLock lock(workers_mutex);
@@ -534,19 +540,80 @@ static Maybe<std::string> ErrorToString(Isolate* isolate,
 return Just<>(std::string(*sv, sv.length()));
 }
 
+staticvoidPrintEmptyJavaScriptStack(JSONWriter* writer) {
+ writer->json_keyvalue("message", "No stack.");
+ writer->json_arraystart("stack");
+ writer->json_element("Unavailable.");
+ writer->json_arrayend();
+
+ writer->json_objectstart("errorProperties");
+ writer->json_objectend();
+}
+
+// Do our best to report the JavaScript stack without calling into JavaScript.
+staticvoidPrintJavaScriptStack(JSONWriter* writer,
+ Isolate* isolate,
+constchar* trigger) {
+// Can not capture the stacktrace when the isolate is in a OOM state.
+if (!strcmp(trigger, "OOMError")) {
+PrintEmptyJavaScriptStack(writer);
+return;
+ }
+
+ HandleScope scope(isolate);
+ RegisterState state;
+ state.pc = nullptr;
+ state.fp = &state;
+ state.sp = &state;
+
+// in-out params
+ SampleInfo info;
+void* samples[MAX_FRAME_COUNT];
+ isolate->GetStackSample(state, samples, MAX_FRAME_COUNT, &info);
+
+ Local<StackTrace> stack = StackTrace::CurrentStackTrace(
+ isolate, MAX_FRAME_COUNT, StackTrace::kDetailed);
+
+if (stack->GetFrameCount() == 0) {
+PrintEmptyJavaScriptStack(writer);
+return;
+ }
+
+ writer->json_keyvalue("message", trigger);
+ writer->json_arraystart("stack");
+for (int i = 0; i < stack->GetFrameCount(); i++) {
+ Local<StackFrame> frame = stack->GetFrame(isolate, i);
+
+ Utf8Value function_name(isolate, frame->GetFunctionName());
+ Utf8Value script_name(isolate, frame->GetScriptName());
+constint line_number = frame->GetLineNumber();
+constint column = frame->GetColumn();
+
+ std::string stack_line = SPrintF(
+"at %s (%s:%d:%d)", *function_name, *script_name, line_number, column);
+ writer->json_element(stack_line);
+ }
+ writer->json_arrayend();
+ writer->json_objectstart("errorProperties");
+ writer->json_objectend();
+}
+
 // Report the JavaScript stack.
 staticvoidPrintJavaScriptErrorStack(JSONWriter* writer,
  Isolate* isolate,
  Local<Value> error,
 constchar* trigger) {
+if (error.IsEmpty()) {
+returnPrintJavaScriptStack(writer, isolate, trigger);
+ }
+
  TryCatch try_catch(isolate);
  HandleScope scope(isolate);
  Local<Context> context = isolate->GetCurrentContext();
  std::string ss = "";
-if ((!strcmp(trigger, "FatalError")) ||
- (!strcmp(trigger, "Signal")) ||
- (!ErrorToString(isolate, context, error).To(&ss))) {
- ss = "No stack.\nUnavailable.\n";
+if (!ErrorToString(isolate, context, error).To(&ss)) {
+PrintEmptyJavaScriptStack(writer);
+return;
  }
 
 int line = ss.find('\n');
@@ -569,6 +636,9 @@ static void PrintJavaScriptErrorStack(JSONWriter* writer,
  }
  writer->json_arrayend();
  }
+
+// Report summary JavaScript error properties backtrace
+PrintJavaScriptErrorProperties(writer, isolate, error);
 }
 
 // Report a native stack backtrace

test/addons/report-fatalerror/binding.cc

@@ -0,0 +1,23 @@
+#include<node.h>
+#include<v8.h>
+
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Object;
+using v8::Value;
+
+voidTriggerFatalError(const FunctionCallbackInfo<Value>& args) {
+ Isolate* isolate = args.GetIsolate();
+
+// Trigger a v8 ApiCheck failure.
+ MaybeLocal<Value> value;
+ value.ToLocalChecked();
+}
+
+voidinit(Local<Object> exports) {
+NODE_SET_METHOD(exports, "triggerFatalError", TriggerFatalError);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, init)

test/addons/report-fatalerror/binding.gyp

@@ -0,0 +1,9 @@
+{
+'targets': [
+ {
+'target_name': 'binding',
+'sources': [ 'binding.cc' ],
+'includes': ['../common.gypi'],
+ }
+ ]
+}

test/addons/report-fatalerror/test.js

@@ -0,0 +1,52 @@
+'use strict';
+
+constcommon=require('../../common');
+constassert=require('assert');
+constpath=require('path');
+constspawnSync=require('child_process').spawnSync;
+consthelper=require('../../common/report.js');
+consttmpdir=require('../../common/tmpdir');
+
+constbinding=path.resolve(__dirname,`./build/${common.buildType}/binding`);
+
+if(process.argv[2]==='child'){
+(functionchildMain(){
+constaddon=require(binding);
+addon.triggerFatalError();
+})();
+return;
+}
+
+constARGS=[
+__filename,
+'child',
+];
+
+{
+// Verify that --report-on-fatalerror is respected when set.
+tmpdir.refresh();
+constargs=['--report-on-fatalerror', ...ARGS];
+constchild=spawnSync(process.execPath,args,{cwd: tmpdir.path});
+assert.notStrictEqual(child.status,0,'Process exited unexpectedly');
+
+constreports=helper.findReports(child.pid,tmpdir.path);
+assert.strictEqual(reports.length,1);
+
+constreport=reports[0];
+helper.validate(report);
+
+constcontent=require(report);
+assert.strictEqual(content.header.trigger,'FatalError');
+
+// Check that the javascript stack is present.
+assert.strictEqual(content.javascriptStack.stack.findIndex((frame)=>frame.match('childMain')),0);
+}
+
+{
+// Verify that --report-on-fatalerror is respected when not set.
+constargs=ARGS;
+constchild=spawnSync(process.execPath,args,{cwd: tmpdir.path});
+assert.notStrictEqual(child.status,0,'Process exited unexpectedly');
+constreports=helper.findReports(child.pid,tmpdir.path);
+assert.strictEqual(reports.length,0);
+}

test/report/test-report-fatal-error.js …eport/test-report-fatalerror-oomerror.jstest/report/test-report-fatal-error.js renamed to test/report/test-report-fatalerror-oomerror.js test/report/test-report-fatal-error.js renamed to test/report/test-report-fatalerror-oomerror.js

@@ -44,10 +44,12 @@ const ARGS = [
 constreport=reports[0];
 helper.validate(report);
 
+constcontent=require(report);
 // Errors occur in a context where env is not available, so thread ID is
 // unknown. Assert this, to verify that the underlying env-less situation is
 // actually reached.
-assert.strictEqual(require(report).header.threadId,null);
+assert.strictEqual(content.header.threadId,null);
+assert.strictEqual(content.header.trigger,'OOMError');
 }
 
 {