Skip to content

Commit 9affb0e

Browse files
author
Matheus Marchini
committed
src: refactor of workqueue related code
All code related to the workqueue commands were refactored by assigning constants in a different file and by creating helper classes to access some node internal properties. Besides that, a new fallback method to determine the current environment was added. This method uses a heuristic approach to try to find the root context of the process. With this, those new commands will work most of the time even without the new symbols added to V8.
1 parent 7837ce8 commit 9affb0e

14 files changed

+666
-111
lines changed

‎llnode.gyp.json‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,10 @@
1616
],
1717

1818
"sources": [
19+
"src/constants.cc",
1920
"src/llnode.cc",
21+
"src/llnode-module.cc",
22+
"src/llnode-constants.cc",
2023
"src/llv8.cc",
2124
"src/llv8-constants.cc",
2225
"src/llscan.cc",

‎src/constants.cc‎

Lines changed: 51 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
#include "src/constants.h"
2+
// TODO(mmarchini): This file shouldn't import llv8-constants nor llv8, as the
3+
// intention is to inherit llv8-constants.h from constants.h
4+
#include <iostream>
5+
#include "src/llv8-constants.h"
6+
#include "src/llv8.h"
7+
8+
namespace llnode {
9+
using v8::Error;
10+
using v8::constants::IsDebugMode;
11+
using v8::constants::LookupConstant;
12+
namespace constants {
13+
14+
void ConstantsWrapper::Assign(SBTarget target) {
15+
loaded_ = false;
16+
target_ = target;
17+
}
18+
19+
int64_t ConstantsWrapper::LoadRawConstant(const char* name, int64_t def) {
20+
Error err;
21+
int64_t v = LookupConstant(target_, name, def, err);
22+
if (err.Fail() && IsDebugMode()) fprintf(stderr, "Failed to load %s\n", name);
23+
24+
return v;
25+
}
26+
27+
28+
int64_t ConstantsWrapper::LoadConstant(const char* name, int64_t def) {
29+
Error err;
30+
int64_t v =
31+
LookupConstant(target_, (kConstantPrefix() + name).c_str(), def, err);
32+
if (err.Fail() && IsDebugMode()) fprintf(stderr, "Failed to load %s\n", name);
33+
34+
return v;
35+
}
36+
37+
38+
int64_t ConstantsWrapper::LoadConstant(const char* name, const char* fallback,
39+
int64_t def) {
40+
Error err;
41+
int64_t v =
42+
LookupConstant(target_, (kConstantPrefix() + name).c_str(), def, err);
43+
if (err.Fail())
44+
v = LookupConstant(target_, (kConstantPrefix() + fallback).c_str(), def,
45+
err);
46+
if (err.Fail() && IsDebugMode()) fprintf(stderr, "Failed to load %s\n", name);
47+
48+
return v;
49+
}
50+
}
51+
}

‎src/constants.h‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
#ifndef SRC_CONSTANTS_H_
2+
#define SRC_CONSTANTS_H_
3+
4+
#include <lldb/API/LLDB.h>
5+
using lldb::SBTarget;
6+
7+
namespace llnode {
8+
namespace constants {
9+
10+
class ConstantsWrapper {
11+
public:
12+
ConstantsWrapper() : loaded_(false) {}
13+
14+
inline bool is_loaded() const { return loaded_; }
15+
16+
void Assign(lldb::SBTarget target);
17+
18+
inline virtual std::string kConstantPrefix() { return ""; };
19+
20+
protected:
21+
int64_t LoadRawConstant(const char* name, int64_t def = -1);
22+
int64_t LoadConstant(const char* name, int64_t def = -1);
23+
int64_t LoadConstant(const char* name, const char* fallback,
24+
int64_t def = -1);
25+
26+
lldb::SBTarget target_;
27+
bool loaded_;
28+
};
29+
}
30+
}
31+
32+
#endif

‎src/llnode-constants.cc‎

Lines changed: 169 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,169 @@
1+
#include <iostream>
2+
3+
#include <lldb/API/LLDB.h>
4+
5+
#include "llnode-constants.h"
6+
#include "llv8-constants.h"
7+
#include "llv8-inl.h"
8+
#include "llv8.h"
9+
10+
using lldb::SBProcess;
11+
using lldb::SBThread;
12+
using lldb::SBError;
13+
using lldb::SBFrame;
14+
using lldb::SBStream;
15+
16+
namespace llnode {
17+
using v8::Error;
18+
using v8::constants::LookupConstant;
19+
namespace node {
20+
namespace constants {
21+
v8::LLV8 llv8;
22+
23+
void Environment::Load() {
24+
kIsolate = LoadRawConstant("node::node_isolate");
25+
kReqWrapQueueOffset = LoadConstant("class__Environment__reqWrapQueue", 1256);
26+
kHandleWrapQueueOffset =
27+
LoadConstant("class__Environment__handleWrapQueue", 1240);
28+
kEnvContextEmbedderDataIndex =
29+
LoadConstant("environment_context_idx_embedder_data", 32);
30+
kCurrentEnvironment = LoadCurrentEnvironment();
31+
}
32+
33+
addr_t Environment::LoadCurrentEnvironment() {
34+
addr_t currentEnvironment = DefaultLoadCurrentEnvironment();
35+
if (currentEnvironment == -1) {
36+
currentEnvironment = FallbackLoadCurrentEnvironment();
37+
}
38+
39+
return currentEnvironment;
40+
}
41+
42+
addr_t Environment::DefaultLoadCurrentEnvironment() {
43+
llv8.Load(target_);
44+
45+
SBProcess process = target_.GetProcess();
46+
SBError sberr;
47+
uint64_t env = -1;
48+
uint64_t isolate_thread = 0;
49+
uint64_t thread_context_ptr = 0;
50+
uint64_t thread_context = 0;
51+
v8::Error err;
52+
53+
if (!(llv8.isolate()->kThreadLocalTopOffset != -1 &&
54+
llv8.thread_local_top()->kContextOffset != -1)) {
55+
// TODO warn user
56+
return env;
57+
}
58+
59+
isolate_thread = kIsolate + llv8.isolate()->kThreadLocalTopOffset;
60+
61+
thread_context_ptr = isolate_thread + llv8.thread_local_top()->kContextOffset;
62+
thread_context = process.ReadPointerFromMemory(thread_context_ptr, sberr);
63+
v8::Context ctx(&llv8, thread_context);
64+
v8::Value native = ctx.Native(err);
65+
env = CurrentEnvironmentFromContext(native);
66+
return env;
67+
}
68+
69+
addr_t Environment::CurrentEnvironmentFromContext(v8::Value context) {
70+
llv8.Load(target_);
71+
v8::Error err;
72+
73+
v8::FixedArray contextArray = v8::FixedArray(context);
74+
v8::FixedArray embed =
75+
contextArray.Get<v8::FixedArray>(llv8.context()->kEmbedderDataIndex, err);
76+
v8::Smi encodedEnv = embed.Get<v8::Smi>(kEnvContextEmbedderDataIndex, err);
77+
if (err.Fail()) {
78+
return -1;
79+
} else {
80+
return encodedEnv.raw();
81+
}
82+
}
83+
84+
addr_t Environment::FallbackLoadCurrentEnvironment() {
85+
addr_t env = -1;
86+
SBProcess process = target_.GetProcess();
87+
SBThread thread = process.GetSelectedThread();
88+
if (!thread.IsValid()) {
89+
return -1;
90+
}
91+
92+
// Load V8 constants from postmortem data
93+
llv8.Load(target_);
94+
95+
{
96+
SBStream desc;
97+
if (!thread.GetDescription(desc)) return -1;
98+
}
99+
100+
SBFrame selected_frame = thread.GetSelectedFrame();
101+
102+
uint32_t num_frames = thread.GetNumFrames();
103+
for (uint32_t i = 0; i < num_frames; i++) {
104+
SBFrame frame = thread.GetFrameAtIndex(i);
105+
106+
if (!frame.GetSymbol().IsValid()) {
107+
v8::Error err;
108+
v8::JSFrame v8_frame(&llv8, static_cast<int64_t>(frame.GetFP()));
109+
v8::JSFunction v8_function = v8_frame.GetFunction(err);
110+
if (err.Fail()) {
111+
continue;
112+
}
113+
v8::Value val;
114+
val = v8_function.GetContext(err);
115+
if (err.Fail()) {
116+
continue;
117+
}
118+
bool found = false;
119+
while (!found) {
120+
v8::Context context(val);
121+
v8::Value native = context.Native(err);
122+
if (err.Success()) {
123+
if (native.raw() == context.raw()) {
124+
found = true;
125+
env = CurrentEnvironmentFromContext(native);
126+
break;
127+
}
128+
}
129+
130+
val = context.Previous(err);
131+
if (err.Fail()) {
132+
break;
133+
}
134+
}
135+
if (found) {
136+
break;
137+
}
138+
}
139+
}
140+
141+
return env;
142+
}
143+
144+
145+
void ReqWrapQueue::Load() {
146+
kHeadOffset = LoadConstant("class__ReqWrapQueue__headOffset", (int64_t)0);
147+
kNextOffset = LoadConstant("class__ReqWrapQueue__nextOffset", (int64_t)8);
148+
}
149+
150+
void ReqWrap::Load() {
151+
kListNodeOffset = LoadConstant("class__ReqWrap__node", (int64_t)48);
152+
}
153+
154+
void HandleWrapQueue::Load() {
155+
kHeadOffset = LoadConstant("class__HandleWrapQueue__headOffset", (int64_t)0);
156+
kNextOffset = LoadConstant("class__HandleWrapQueue__nextOffset", (int64_t)8);
157+
}
158+
159+
void HandleWrap::Load() {
160+
kListNodeOffset = LoadConstant("class__HandleWrap__node", (int64_t)48);
161+
}
162+
163+
void BaseObject::Load() {
164+
kPersistentHandleOffset =
165+
LoadConstant("class__BaseObject__persistent_handle", (int64_t)8);
166+
}
167+
}
168+
}
169+
}

‎src/llnode-constants.h‎

Lines changed: 104 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,104 @@
1+
#ifndef SRC_LLNODE_CONSTANTS_H_
2+
#define SRC_LLNODE_CONSTANTS_H_
3+
4+
#include <lldb/API/LLDB.h>
5+
#include "src/constants.h"
6+
#include "src/llv8.h"
7+
8+
using lldb::addr_t;
9+
10+
namespace llnode {
11+
using constants::ConstantsWrapper;
12+
namespace node {
13+
namespace constants {
14+
#define MODULE_DEFAULT_METHODS(NAME) \
15+
NAME() {} \
16+
inline NAME* operator()() { \
17+
if (loaded_) return this; \
18+
loaded_ = true; \
19+
Load(); \
20+
return this; \
21+
}
22+
23+
24+
class Module : public ConstantsWrapper {
25+
public:
26+
inline std::string kConstantPrefix() override { return "nodedbg_"; };
27+
};
28+
29+
class Environment : public Module {
30+
public:
31+
MODULE_DEFAULT_METHODS(Environment);
32+
33+
int64_t kIsolate;
34+
int64_t kReqWrapQueueOffset;
35+
int64_t kHandleWrapQueueOffset;
36+
int64_t kEnvContextEmbedderDataIndex;
37+
addr_t kCurrentEnvironment;
38+
39+
protected:
40+
void Load();
41+
42+
private:
43+
addr_t LoadCurrentEnvironment();
44+
addr_t DefaultLoadCurrentEnvironment();
45+
addr_t FallbackLoadCurrentEnvironment();
46+
addr_t CurrentEnvironmentFromContext(v8::Value context);
47+
};
48+
49+
class ReqWrapQueue : public Module {
50+
public:
51+
MODULE_DEFAULT_METHODS(ReqWrapQueue);
52+
53+
int64_t kHeadOffset;
54+
int64_t kNextOffset;
55+
56+
protected:
57+
void Load();
58+
};
59+
60+
class ReqWrap : public Module {
61+
public:
62+
MODULE_DEFAULT_METHODS(ReqWrap);
63+
64+
int64_t kListNodeOffset;
65+
66+
protected:
67+
void Load();
68+
};
69+
70+
class HandleWrapQueue : public Module {
71+
public:
72+
MODULE_DEFAULT_METHODS(HandleWrapQueue);
73+
74+
int64_t kHeadOffset;
75+
int64_t kNextOffset;
76+
77+
protected:
78+
void Load();
79+
};
80+
81+
class HandleWrap : public Module {
82+
public:
83+
MODULE_DEFAULT_METHODS(HandleWrap);
84+
85+
int64_t kListNodeOffset;
86+
87+
protected:
88+
void Load();
89+
};
90+
91+
class BaseObject : public Module {
92+
public:
93+
MODULE_DEFAULT_METHODS(BaseObject);
94+
95+
int64_t kPersistentHandleOffset;
96+
97+
protected:
98+
void Load();
99+
};
100+
}
101+
}
102+
}
103+
104+
#endif

0 commit comments

Comments
 (0)