src: add commands to inspect the workqueue

Added two new commands (getactivehandles and getactiverequests)
which prints all pending handles and requests (same return
given by process._getActiveHandles() and process._getActiveRequests()).
Those changes were built upon the symbols added on nodejs/node#14901,
which means it's currently not working with node's latest build.

Fixes: nodejs#100
Ref: nodejs/node#14901

README.md

@@ -240,6 +240,11 @@ The following subcommands are supported:
                           * -n, --name  name     - all properties with the specified name
                           * -s, --string string  - all properties that refer to the specified JavaScript string value
 
+<!--- TODO fix indentation for the other commands --->
+      getactivehandles  -- *EXPERIMENTAL* Equivalent to running process._getActiveHandles. This command is still being
+                           developed and for now it only works building node from source.
+      getactiverequests -- *EXPERIMENTAL* Equivalent to running process._getActiveRequests. This command is still being
+                           developed and for now it only works building node from source.
       inspect         -- Print detailed description and contents of the JavaScript value.
 
                          Possible flags (all optional):

src/llnode.cc

@@ -4,12 +4,15 @@
 #include <string.h>
 
 #include <cinttypes>
+#include <iostream>
+#include <sstream>
 
 #include <lldb/API/SBExpressionOptions.h>
 
 #include "src/llnode.h"
 #include "src/llscan.h"
 #include "src/llv8.h"
+#include "src/llv8-constants.h"
 
 namespace llnode {
 
@@ -26,6 +29,12 @@ using lldb::SBThread;
 using lldb::SBValue;
 using lldb::eReturnStatusFailed;
 using lldb::eReturnStatusSuccessFinishResult;
+using lldb::SBProcess;
+using lldb::SBAddress;
+using lldb::SBSymbolContext;
+using lldb::SBSymbolContextList;
+using lldb::addr_t;
+using v8::constants::LookupConstant;
 
 v8::LLV8 llv8;
 
@@ -299,6 +308,176 @@ bool ListCmd::DoExecute(SBDebugger d, char** cmd,
   return true;
 }
 
+bool GetActiveHandlesCmd::DoExecute(SBDebugger d, char** cmd,
+                            SBCommandReturnObject& result) {
+  SBTarget target = d.GetSelectedTarget();
+  SBProcess process = target.GetProcess();
+  SBThread thread = process.GetSelectedThread();
+  SBError sberr;
+  std::ostringstream resultMsg;
+  v8::Value::InspectOptions inspect_options;
+  inspect_options.detailed = true;
+
+  llv8.Load(target);
+
+  int size = 8;  // TODO size is arch-dependent
+  int64_t envPtr = 0;
+  uint64_t env = 0;
+  int64_t queue = 0;
+  int64_t head = 0;
+  int64_t next = 0;
+  int64_t node = 0;
+  int64_t persistant_handle = 0;
+  v8::Error err2;
+
+  envPtr = LookupConstant(target, "nodedbg_currentEnvironment", envPtr, err2);
+  process.ReadMemory(envPtr, &env, size, sberr);
+
+  queue = LookupConstant(target, "nodedbg_class__Environment__handleWrapQueue", queue, err2);
+  head = LookupConstant(target, "nodedbg_class__HandleWrapQueue__headOffset", head, err2);
+  next = LookupConstant(target, "nodedbg_class__HandleWrapQueue__nextOffset", next, err2);
+  node = LookupConstant(target, "nodedbg_class__HandleWrap__node", node, err2);
+  persistant_handle = LookupConstant(target, "nodedbg_class__BaseObject__persistant_handle", persistant_handle, err2);
+
+  // uint8_t *buffer = new uint8_t[size];
+  // XXX Ozadia time
+  uint64_t buffer = 0;
+  bool go=true;
+  if (!thread.IsValid()) {
+    result.SetError("No valid process, please start something\n");
+    return false;
+  }
+
+  int activeHandles = 0;
+  uint64_t currentNode = env;
+  currentNode += queue;  // env.handle_wrap_queue_
+  currentNode += head;  // env.handle_wrap_queue_.head_
+  currentNode += next;  // env.handle_wrap_queue_.head_.next_
+  process.ReadMemory(currentNode, &buffer, size, sberr);
+  currentNode = buffer;
+  // TODO needs a stop condition, currently it's being stopped by a break
+  while(go) {
+    addr_t myMemory = currentNode;
+    myMemory  = myMemory - node;  // wrap
+    myMemory += persistant_handle;
+    // w->persistent().IsEmpty()
+    if(myMemory == 0) {
+      continue;
+    }
+
+    process.ReadMemory(myMemory, &buffer, size, sberr);
+    myMemory = buffer;
+    process.ReadMemory(myMemory, &buffer, size, sberr);
+    // TODO needs a better check
+    if(sberr.Fail()) {
+      break;
+    }
+
+    v8::JSObject v8_object(&llv8, buffer);
+    v8::Error err;
+    std::string res = v8_object.Inspect(&inspect_options, err);
+    if (err.Fail()) {
+      // result.SetError("Failed to evaluate expression");
+      break;
+    }
+
+    activeHandles++;
+    resultMsg << res.c_str() << std::endl;
+
+    currentNode += next;  // env.handle_wrap_queue_.head_.next_->next_->(...)->next_
+    process.ReadMemory(currentNode, &buffer, size, sberr);
+    currentNode = buffer;
+  }
+  result.Printf("Active handles: %d\n\n", activeHandles);
+  result.Printf("%s", resultMsg.str().c_str());
+  return true;
+}
+
+bool GetActiveRequestsCmd::DoExecute(SBDebugger d, char** cmd,
+                            SBCommandReturnObject& result) {
+  SBTarget target = d.GetSelectedTarget();
+  SBProcess process = target.GetProcess();
+  SBThread thread = process.GetSelectedThread();
+  SBError sberr;
+  std::ostringstream resultMsg;
+  v8::Value::InspectOptions inspect_options;
+  inspect_options.detailed = true;
+
+  llv8.Load(target);
+
+  int size = 8;  // TODO size is arch-dependent
+  int64_t envPtr = 0;
+  uint64_t env = 0;
+  int64_t queue = 0;
+  int64_t head = 0;
+  int64_t next = 0;
+  int64_t node = 0;
+  int64_t persistant_handle = 0;
+  v8::Error err2;
+
+  envPtr = LookupConstant(target, "nodedbg_currentEnvironment", envPtr, err2);
+  process.ReadMemory(envPtr, &env, size, sberr);
+
+  queue = LookupConstant(target, "nodedbg_class__Environment__reqWrapQueue", queue, err2);
+  head = LookupConstant(target, "nodedbg_class__ReqWrapQueue__headOffset", head, err2);
+  next = LookupConstant(target, "nodedbg_class__ReqWrapQueue__nextOffset", next, err2);
+  node = LookupConstant(target, "nodedbg_class__ReqWrap__node", node, err2);
+  persistant_handle = LookupConstant(target, "nodedbg_class__BaseObject__persistant_handle", persistant_handle, err2);
+
+  // uint8_t *buffer = new uint8_t[size];
+  // XXX Ozadia time
+  uint64_t buffer = 0;
+  bool go=true;
+  if (!thread.IsValid()) {
+    result.SetError("No valid process, please start something\n");
+    return false;
+  }
+
+  int activeHandles = 0;
+  uint64_t currentNode = env;
+  currentNode += queue;  // env.handle_wrap_queue_
+  currentNode += head;  // env.handle_wrap_queue_.head_
+  currentNode += next;  // env.handle_wrap_queue_.head_.next_
+  process.ReadMemory(currentNode, &buffer, size, sberr);
+  currentNode = buffer;
+  // TODO needs a stop condition
+  while(go) {
+    addr_t myMemory = currentNode;
+    myMemory  = myMemory - node;
+    myMemory += persistant_handle;
+    // w->persistent().IsEmpty()
+    if(myMemory == 0) {
+      continue;
+    }
+
+    process.ReadMemory(myMemory, &buffer, size, sberr);
+    myMemory = buffer;
+    process.ReadMemory(myMemory, &buffer, size, sberr);
+    // TODO needs a better check
+    if(sberr.Fail()) {
+      break;
+    }
+
+    v8::JSObject v8_object(&llv8, buffer);
+    v8::Error err;
+    std::string res = v8_object.Inspect(&inspect_options, err);
+    if (err.Fail()) {
+      // result.SetError("Failed to evaluate expression");
+      break;
+    }
+
+    activeHandles++;
+    resultMsg << res.c_str() << std::endl;
+
+    currentNode += next;  // env.handle_wrap_queue_.head_.next_->next_->(...)->next_
+    process.ReadMemory(currentNode, &buffer, size, sberr);
+    currentNode = buffer;
+  }
+  result.Printf("Active handles: %d\n\n", activeHandles);
+  result.Printf("%s", resultMsg.str().c_str());
+  return true;
+}
+
 }  // namespace llnode
 
 namespace lldb {
@@ -384,6 +563,18 @@ bool PluginInitialize(SBDebugger d) {
       "JavaScript string value\n"
       "\n");
 
+  v8.AddCommand(
+      "getactivehandles", new llnode::GetActiveHandlesCmd(),
+      "*EXPERIMENTAL* Equivalent to running process._getActiveHandles. "
+      "This command is still being developed and for now it only works "
+      "building node from source.\n");
+
+  v8.AddCommand(
+      "getactiverequests", new llnode::GetActiveRequestsCmd(),
+      "*EXPERIMENTAL* Equivalent to running process._getActiveRequests. "
+      "This command is still being developed and for now it only works "
+      "building node from source.\n");
+
   return true;
 }
 

src/llnode.h

@@ -35,6 +35,22 @@ class PrintCmd : public CommandBase {
   bool detailed_;
 };
 
+class GetActiveHandlesCmd : public CommandBase {
+ public:
+  ~GetActiveHandlesCmd() override {}
+
+  bool DoExecute(lldb::SBDebugger d, char** cmd,
+                 lldb::SBCommandReturnObject& result) override;
+};
+
+class GetActiveRequestsCmd : public CommandBase {
+ public:
+  ~GetActiveRequestsCmd() override {}
+
+  bool DoExecute(lldb::SBDebugger d, char** cmd,
+                 lldb::SBCommandReturnObject& result) override;
+};
+
 class ListCmd : public CommandBase {
  public:
   ~ListCmd() override {}

src/llv8-constants.cc

@@ -38,7 +38,7 @@ void Module::Assign(SBTarget target, Common* common) {
 }
 
 
-static int64_t LookupConstant(SBTarget target, const char* name, int64_t def,
+int64_t LookupConstant(SBTarget target, const char* name, int64_t def,
                               Error& err) {
   int64_t res;
 

src/llv8-constants.h

@@ -3,10 +3,16 @@
 
 #include <lldb/API/LLDB.h>
 
+using lldb::SBTarget;
+
 namespace llnode {
 namespace v8 {
+class Error;
 namespace constants {
 
+int64_t LookupConstant(SBTarget target, const char* name, int64_t def,
+                              Error& err);
+
 // Forward declarations
 class Common;