src: add commands to inspect the workqueue

README.md

@@ -208,6 +208,12 @@ 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
 
+ getactivehandles -- Print all pending handles in the queue. Equivalent to running process._getActiveHandles() on
+ the living process.
+
+ getactiverequests -- Print all pending handles in the queue. Equivalent to running process._getActiveHandles() on
+ the living process.
+
  inspect -- Print detailed description and contents of the JavaScript value.
 
  Possible flags (all optional):

binding.gyp

@@ -16,6 +16,7 @@
  "<(lldb_include_dir)",
  ],
 
+
  "cflags" : [ "-std=c++11" ],
 
  "conditions": [
@@ -58,10 +59,14 @@
  "target_name": "plugin",
  "type": "shared_library",
  "sources": [
+ "src/constants.cc",
+ "src/error.cc",
  "src/llnode.cc",
  "src/llv8.cc",
  "src/llv8-constants.cc",
  "src/llscan.cc",
+ "src/node.cc",
+ "src/node-constants.cc",
  ]
  }],
 }

src/constants.cc

@@ -0,0 +1,121 @@
+#include <cinttypes>
+
+#include <lldb/API/SBExpressionOptions.h>
+
+#include "src/constants.h"
+
+using lldb::SBAddress;
+using lldb::SBError;
+using lldb::SBSymbol;
+using lldb::SBSymbolContext;
+using lldb::SBSymbolContextList;
+
+namespace llnode {
+
+template <typename T>
+T ReadSymbolFromTarget(SBTarget& target, SBAddress& start, const char* name,
+ Error& err) {
+ SBError sberr;
+ T res = 0;
+ target.ReadMemory(start, &res, sizeof(T), sberr);
+ if (!sberr.Fail()) {
+ err = Error::Ok();
+ } else {
+ err = Error::Failure("Failed to read symbol %s", name);
+ }
+ return res;
+}
+
+int64_t Constants::LookupConstant(SBTarget target, const char* name,
+ int64_t def, Error& err) {
+ int64_t res = 0;
+ res = def;
+
+ SBSymbolContextList context_list = target.FindSymbols(name);
+
+ if (!context_list.IsValid() || context_list.GetSize() == 0) {
+ err = Error::Failure("Failed to find symbol %s", name);
+ return res;
+ }
+
+ SBSymbolContext context = context_list.GetContextAtIndex(0);
+ SBSymbol symbol = context.GetSymbol();
+ if (!symbol.IsValid()) {
+ err = Error::Failure("Failed to fetch symbol %s from context", name);
+ return res;
+ }
+
+ SBAddress start = symbol.GetStartAddress();
+ SBAddress end = symbol.GetEndAddress();
+ uint32_t size = end.GetOffset() - start.GetOffset();
+
+ // NOTE: size could be bigger for at the end symbols
+ if (size >= 8) {
+ res = ReadSymbolFromTarget<int64_t>(target, start, name, err);
+ } else if (size == 4) {
+ int32_t tmp = ReadSymbolFromTarget<int32_t>(target, start, name, err);
+ res = static_cast<int64_t>(tmp);
+ } else if (size == 2) {
+ int16_t tmp = ReadSymbolFromTarget<int16_t>(target, start, name, err);
+ res = static_cast<int64_t>(tmp);
+ } else if (size == 1) {
+ int8_t tmp = ReadSymbolFromTarget<int8_t>(target, start, name, err);
+ res = static_cast<int64_t>(tmp);
+ } else {
+ err = Error::Failure("Unexpected symbol size %" PRIu32 " of symbol %s",
+ size, name);
+ }
+
+ return res;
+}
+
+void Constants::Assign(SBTarget target) {
+ loaded_ = false;
+ target_ = target;
+}
+
+
+int64_t Constants::LoadRawConstant(const char* name, int64_t def) {
+ Error err;
+ int64_t v = Constants::LookupConstant(target_, name, def, err);
+ if (err.Fail()) {
+ Error::PrintInDebugMode(
+ "Failed to load raw constant %s, default to %" PRId64, name, def);
+ }
+
+ return v;
+}
+
+int64_t Constants::LoadConstant(const char* name, Error& err, int64_t def) {
+ int64_t v = Constants::LookupConstant(
+ target_, (constant_prefix() + name).c_str(), def, err);
+ return v;
+}
+
+int64_t Constants::LoadConstant(const char* name, int64_t def) {
+ Error err;
+ int64_t v = LoadConstant(name, err, def);
+ if (err.Fail()) {
+ Error::PrintInDebugMode("Failed to load constant %s, default to %" PRId64,
+ name, def);
+ }
+
+ return v;
+}
+
+int64_t Constants::LoadConstant(const char* name, const char* fallback,
+ int64_t def) {
+ Error err;
+ int64_t v = LoadConstant(name, err, def);
+ if (err.Fail()) v = LoadConstant(fallback, err, def);
+ if (err.Fail()) {
+ Error::PrintInDebugMode(
+ "Failed to load constant %s, fallback %s, default to %" PRId64, name,
+ fallback, def);
+ }
+
+ return v;
+}
+
+
+} // namespace llnode

src/constants.h

@@ -0,0 +1,47 @@
+#ifndef SRC_CONSTANTS_H_
+#define SRC_CONSTANTS_H_
+
+#include <lldb/API/LLDB.h>
+#include <string>
+
+#include "src/error.h"
+
+using lldb::SBTarget;
+
+namespace llnode {
+
+#define CONSTANTS_DEFAULT_METHODS(NAME) \
+ inline NAME* operator()() { \
+ if (loaded_) return this; \
+ loaded_ = true; \
+ Load(); \
+ return this; \
+ }
+
+class Constants {
+ public:
+ Constants() : loaded_(false) {}
+
+ inline bool is_loaded() const { return loaded_; }
+
+ void Assign(lldb::SBTarget target);
+
+ inline virtual std::string constant_prefix() { return ""; };
+
+ static int64_t LookupConstant(SBTarget target, const char* name, int64_t def,
+ Error& err);
+
+ protected:
+ int64_t LoadRawConstant(const char* name, int64_t def = -1);
+ int64_t LoadConstant(const char* name, Error& err, int64_t def = -1);
+ int64_t LoadConstant(const char* name, int64_t def = -1);
+ int64_t LoadConstant(const char* name, const char* fallback,
+ int64_t def = -1);
+
+ lldb::SBTarget target_;
+ bool loaded_;
+};
+
+} // namespace llnode
+
+#endif

src/error.cc

@@ -0,0 +1,46 @@
+#include <cstdarg>
+
+#include "error.h"
+
+namespace llnode {
+bool Error::is_debug_mode = false;
+
+Error::Error(bool failed, const char* format, ...) {
+ failed_ = failed;
+ char tmp[kMaxMessageLength];
+ va_list arglist;
+ va_start(arglist, format);
+ vsnprintf(tmp, sizeof(tmp), format, arglist);
+ va_end(arglist);
+ msg_ = tmp;
+}
+
+
+void Error::PrintInDebugMode(const char* format, ...) {
+ if (!is_debug_mode) {
+ return;
+ }
+ char fmt[kMaxMessageLength];
+ snprintf(fmt, sizeof(fmt), "[llv8] %s\n", format);
+ va_list arglist;
+ va_start(arglist, format);
+ vfprintf(stderr, fmt, arglist);
+ va_end(arglist);
+}
+
+
+Error Error::Failure(std::string msg) {
+ PrintInDebugMode("%s", msg.c_str());
+ return Error(true, msg);
+}
+
+
+Error Error::Failure(const char* format, ...) {
+ char tmp[kMaxMessageLength];
+ va_list arglist;
+ va_start(arglist, format);
+ vsnprintf(tmp, sizeof(tmp), format, arglist);
+ va_end(arglist);
+ return Error::Failure(std::string(tmp));
+}
+} // namespace llnode

src/error.h

@@ -0,0 +1,37 @@
+#ifndef SRC_ERROR_H_
+#define SRC_ERROR_H_
+
+#include <string>
+
+namespace llnode {
+
+class Error {
+ public:
+ Error() : failed_(false), msg_("") {}
+ Error(bool failed, std::string msg) : failed_(failed), msg_(msg) {}
+ Error(bool failed, const char* format, ...)
+ __attribute__((format(printf, 3, 4)));
+
+ static inline Error Ok() { return Error(false, "ok"); }
+ static Error Failure(std::string msg);
+ static Error Failure(const char* format, ...)
+ __attribute__((format(printf, 1, 2)));
+ static void PrintInDebugMode(const char* format, ...)
+ __attribute__((format(printf, 1, 2)));
+
+ inline bool Success() const { return !Fail(); }
+ inline bool Fail() const { return failed_; }
+
+ inline const char* GetMessage() { return msg_.c_str(); }
+
+ static void SetDebugMode(bool mode) { is_debug_mode = mode; }
+
+ private:
+ bool failed_;
+ std::string msg_;
+ static const size_t kMaxMessageLength = 128;
+ static bool is_debug_mode;
+};
+} // namespace llnode
+
+#endif