fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Partial thread data plumbing.

Browse Source
This commit is contained in:
Ben Vanik
2015-06-16 21:53:40 -07:00
parent aae45515ae
commit b750370759
13 changed files with 288 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
src/xenia/debug/debugger.cc
View File

@@ -35,6 +35,7 @@
#include "xenia/debug/proto/control_generated.h"
#include "xenia/debug/proto/messages_generated.h"
#include "xenia/debug/proto/modules_generated.h"
#include "xenia/debug/proto/threads_generated.h"
DEFINE_string(debug_session_path, "", "Debug output path.");
DEFINE_int32(debug_port, 19000, "Port the debugger listens on.");
@@ -400,6 +401,38 @@ void Debugger::OnMessage(std::vector<uint8_t> buffer) {
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_ListThreadsRequest: {
response_data_type = proto::ResponseData_ListThreadsResponse;
auto threads =
emulator()->kernel_state()->object_table()->GetObjectsByType<XThread>(
XObject::kTypeThread);
std::vector<flatbuffers::Offset<proto::Thread>> thread_list;
for (size_t i = 0; i < threads.size(); ++i) {
auto& thread = threads[i];
auto thread_name_string = fbb.CreateString(thread->name());
auto thread_builder = proto::ThreadBuilder(fbb);
// thread_builder.add_type();
// thread_builder.add_stack_size();
// thread_builder.add_xapi_thread_startup();
// thread_builder.add_start_address();
// thread_builder.add_start_context();
// thread_builder.add_creation_flags();
thread_builder.add_tls_address(thread->tls_ptr());
thread_builder.add_pcr_address(thread->pcr_ptr());
thread_builder.add_thread_state_address(thread->thread_state_ptr());
thread_builder.add_thread_id(thread->thread_id());
thread_builder.add_name(thread_name_string);
thread_builder.add_priority(thread->priority());
thread_builder.add_affinity(thread->affinity());
// thread_builder.add_state(thread->);
thread_list.push_back(thread_builder.Finish());
}
auto threads_offset = fbb.CreateVector(thread_list);
auto response_data = proto::ListThreadsResponseBuilder(fbb);
response_data.add_thread(threads_offset);
response_data_offset = response_data.Finish().Union();
} break;
case proto::RequestData_StopRequest: {
response_data_type = proto::ResponseData_StopResponse;
auto response_data = proto::StopResponseBuilder(fbb);

4
src/xenia/debug/proto/messages.fbs
View File

@@ -31,6 +31,8 @@ union RequestData {
ListFunctionsRequest,
GetFunctionRequest,
ListThreadsRequest,
StopRequest,
BreakRequest,
ContinueRequest,
@@ -55,6 +57,8 @@ union ResponseData {
ListFunctionsResponse,
GetFunctionResponse,
ListThreadsResponse,
StopResponse,
BreakResponse,
ContinueResponse,

51
src/xenia/debug/proto/messages_generated.h
View File

@@ -91,14 +91,23 @@ enum RequestData {
RequestData_GetModuleRequest = 7,
RequestData_ListFunctionsRequest = 8,
RequestData_GetFunctionRequest = 9,
RequestData_StopRequest = 10,
RequestData_BreakRequest = 11,
RequestData_ContinueRequest = 12,
RequestData_StepRequest = 13
RequestData_ListThreadsRequest = 10,
RequestData_StopRequest = 11,
RequestData_BreakRequest = 12,
RequestData_ContinueRequest = 13,
RequestData_StepRequest = 14
};
inline const char **EnumNamesRequestData() {
static const char *names[] = { "NONE", "AttachRequest", "ListBreakpointsRequest", "AddBreakpointsRequest", "UpdateBreakpointsRequest", "RemoveBreakpointsRequest", "ListModulesRequest", "GetModuleRequest", "ListFunctionsRequest", "GetFunctionRequest", "StopRequest", "BreakRequest", "ContinueRequest", "StepRequest", nullptr };
static const char *names[] = {
"NONE", "AttachRequest",
"ListBreakpointsRequest", "AddBreakpointsRequest",
"UpdateBreakpointsRequest", "RemoveBreakpointsRequest",
"ListModulesRequest", "GetModuleRequest",
"ListFunctionsRequest", "GetFunctionRequest",
"ListThreadsRequest", "StopRequest",
"BreakRequest", "ContinueRequest",
"StepRequest", nullptr};
return names;
}
@@ -117,16 +126,26 @@ enum ResponseData {
ResponseData_GetModuleResponse = 7,
ResponseData_ListFunctionsResponse = 8,
ResponseData_GetFunctionResponse = 9,
ResponseData_StopResponse = 10,
ResponseData_BreakResponse = 11,
ResponseData_ContinueResponse = 12,
ResponseData_StepResponse = 13,
ResponseData_BreakpointEvent = 14,
ResponseData_AccessViolationEvent = 15
ResponseData_ListThreadsResponse = 10,
ResponseData_StopResponse = 11,
ResponseData_BreakResponse = 12,
ResponseData_ContinueResponse = 13,
ResponseData_StepResponse = 14,
ResponseData_BreakpointEvent = 15,
ResponseData_AccessViolationEvent = 16
};
inline const char **EnumNamesResponseData() {
static const char *names[] = { "NONE", "AttachResponse", "ListBreakpointsResponse", "AddBreakpointsResponse", "UpdateBreakpointsResponse", "RemoveBreakpointsResponse", "ListModulesResponse", "GetModuleResponse", "ListFunctionsResponse", "GetFunctionResponse", "StopResponse", "BreakResponse", "ContinueResponse", "StepResponse", "BreakpointEvent", "AccessViolationEvent", nullptr };
static const char *names[] = {
"NONE", "AttachResponse",
"ListBreakpointsResponse", "AddBreakpointsResponse",
"UpdateBreakpointsResponse", "RemoveBreakpointsResponse",
"ListModulesResponse", "GetModuleResponse",
"ListFunctionsResponse", "GetFunctionResponse",
"ListThreadsResponse", "StopResponse",
"BreakResponse", "ContinueResponse",
"StepResponse", "BreakpointEvent",
"AccessViolationEvent", nullptr};
return names;
}
@@ -304,6 +323,10 @@ inline bool VerifyRequestData(flatbuffers::Verifier &verifier, const void *union
case RequestData_GetModuleRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetModuleRequest *>(union_obj));
case RequestData_ListFunctionsRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListFunctionsRequest *>(union_obj));
case RequestData_GetFunctionRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetFunctionRequest *>(union_obj));
case RequestData_ListThreadsRequest:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListThreadsRequest *>(
union_obj));
case RequestData_StopRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StopRequest *>(union_obj));
case RequestData_BreakRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::BreakRequest *>(union_obj));
case RequestData_ContinueRequest: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ContinueRequest *>(union_obj));
@@ -324,6 +347,10 @@ inline bool VerifyResponseData(flatbuffers::Verifier &verifier, const void *unio
case ResponseData_GetModuleResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetModuleResponse *>(union_obj));
case ResponseData_ListFunctionsResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ListFunctionsResponse *>(union_obj));
case ResponseData_GetFunctionResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::GetFunctionResponse *>(union_obj));
case ResponseData_ListThreadsResponse:
return verifier.VerifyTable(
reinterpret_cast<const xe::debug::proto::ListThreadsResponse *>(
union_obj));
case ResponseData_StopResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::StopResponse *>(union_obj));
case ResponseData_BreakResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::BreakResponse *>(union_obj));
case ResponseData_ContinueResponse: return verifier.VerifyTable(reinterpret_cast<const xe::debug::proto::ContinueResponse *>(union_obj));

17
src/xenia/debug/proto/threads.fbs
View File

@@ -13,9 +13,26 @@ table Thread {
// module_id:uint;
// creation callstack
stack_size:uint;
xapi_thread_startup:uint;
start_address:uint;
start_context:uint;
creation_flags:uint;
tls_address:uint;
pcr_address:uint;
thread_state_address:uint;
thread_id:uint;
name:string;
priority:uint;
affinity:uint;
state:uint;
}
table ListThreadsRequest {
}
table ListThreadsResponse {
thread:[Thread];
}

114
src/xenia/debug/proto/threads_generated.h
View File

@@ -36,10 +36,39 @@ inline const char *EnumNameThreadType(ThreadType e) { return EnumNamesThreadType
struct Thread FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const xe::debug::proto::XObject *object() const { return GetStruct<const xe::debug::proto::XObject *>(4); }
ThreadType type() const { return static_cast<ThreadType>(GetField<int8_t>(6, 0)); }
uint32_t stack_size() const { return GetField<uint32_t>(8, 0); }
uint32_t xapi_thread_startup() const { return GetField<uint32_t>(10, 0); }
uint32_t start_address() const { return GetField<uint32_t>(12, 0); }
uint32_t start_context() const { return GetField<uint32_t>(14, 0); }
uint32_t creation_flags() const { return GetField<uint32_t>(16, 0); }
uint32_t tls_address() const { return GetField<uint32_t>(18, 0); }
uint32_t pcr_address() const { return GetField<uint32_t>(20, 0); }
uint32_t thread_state_address() const { return GetField<uint32_t>(22, 0); }
uint32_t thread_id() const { return GetField<uint32_t>(24, 0); }
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(26);
}
uint32_t priority() const { return GetField<uint32_t>(28, 0); }
uint32_t affinity() const { return GetField<uint32_t>(30, 0); }
uint32_t state() const { return GetField<uint32_t>(32, 0); }
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<xe::debug::proto::XObject>(verifier, 4 /* object */) &&
VerifyField<int8_t>(verifier, 6 /* type */) &&
VerifyField<uint32_t>(verifier, 8 /* stack_size */) &&
VerifyField<uint32_t>(verifier, 10 /* xapi_thread_startup */) &&
VerifyField<uint32_t>(verifier, 12 /* start_address */) &&
VerifyField<uint32_t>(verifier, 14 /* start_context */) &&
VerifyField<uint32_t>(verifier, 16 /* creation_flags */) &&
VerifyField<uint32_t>(verifier, 18 /* tls_address */) &&
VerifyField<uint32_t>(verifier, 20 /* pcr_address */) &&
VerifyField<uint32_t>(verifier, 22 /* thread_state_address */) &&
VerifyField<uint32_t>(verifier, 24 /* thread_id */) &&
VerifyField<flatbuffers::uoffset_t>(verifier, 26 /* name */) &&
verifier.Verify(name()) &&
VerifyField<uint32_t>(verifier, 28 /* priority */) &&
VerifyField<uint32_t>(verifier, 30 /* affinity */) &&
VerifyField<uint32_t>(verifier, 32 /* state */) &&
verifier.EndTable();
}
};
@@ -49,18 +78,75 @@ struct ThreadBuilder {
flatbuffers::uoffset_t start_;
void add_object(const xe::debug::proto::XObject *object) { fbb_.AddStruct(4, object); }
void add_type(ThreadType type) { fbb_.AddElement<int8_t>(6, static_cast<int8_t>(type), 0); }
void add_stack_size(uint32_t stack_size) {
fbb_.AddElement<uint32_t>(8, stack_size, 0);
}
void add_xapi_thread_startup(uint32_t xapi_thread_startup) {
fbb_.AddElement<uint32_t>(10, xapi_thread_startup, 0);
}
void add_start_address(uint32_t start_address) {
fbb_.AddElement<uint32_t>(12, start_address, 0);
}
void add_start_context(uint32_t start_context) {
fbb_.AddElement<uint32_t>(14, start_context, 0);
}
void add_creation_flags(uint32_t creation_flags) {
fbb_.AddElement<uint32_t>(16, creation_flags, 0);
}
void add_tls_address(uint32_t tls_address) {
fbb_.AddElement<uint32_t>(18, tls_address, 0);
}
void add_pcr_address(uint32_t pcr_address) {
fbb_.AddElement<uint32_t>(20, pcr_address, 0);
}
void add_thread_state_address(uint32_t thread_state_address) {
fbb_.AddElement<uint32_t>(22, thread_state_address, 0);
}
void add_thread_id(uint32_t thread_id) {
fbb_.AddElement<uint32_t>(24, thread_id, 0);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(26, name);
}
void add_priority(uint32_t priority) {
fbb_.AddElement<uint32_t>(28, priority, 0);
}
void add_affinity(uint32_t affinity) {
fbb_.AddElement<uint32_t>(30, affinity, 0);
}
void add_state(uint32_t state) { fbb_.AddElement<uint32_t>(32, state, 0); }
ThreadBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ThreadBuilder &operator=(const ThreadBuilder &);
flatbuffers::Offset<Thread> Finish() {
auto o = flatbuffers::Offset<Thread>(fbb_.EndTable(start_, 2));
auto o = flatbuffers::Offset<Thread>(fbb_.EndTable(start_, 15));
return o;
}
};
inline flatbuffers::Offset<Thread> CreateThread(flatbuffers::FlatBufferBuilder &_fbb,
const xe::debug::proto::XObject *object = 0,
ThreadType type = ThreadType_Kernel) {
inline flatbuffers::Offset<Thread> CreateThread(
flatbuffers::FlatBufferBuilder &_fbb,
const xe::debug::proto::XObject *object = 0,
ThreadType type = ThreadType_Kernel, uint32_t stack_size = 0,
uint32_t xapi_thread_startup = 0, uint32_t start_address = 0,
uint32_t start_context = 0, uint32_t creation_flags = 0,
uint32_t tls_address = 0, uint32_t pcr_address = 0,
uint32_t thread_state_address = 0, uint32_t thread_id = 0,
flatbuffers::Offset<flatbuffers::String> name = 0, uint32_t priority = 0,
uint32_t affinity = 0, uint32_t state = 0) {
ThreadBuilder builder_(_fbb);
builder_.add_state(state);
builder_.add_affinity(affinity);
builder_.add_priority(priority);
builder_.add_name(name);
builder_.add_thread_id(thread_id);
builder_.add_thread_state_address(thread_state_address);
builder_.add_pcr_address(pcr_address);
builder_.add_tls_address(tls_address);
builder_.add_creation_flags(creation_flags);
builder_.add_start_context(start_context);
builder_.add_start_address(start_address);
builder_.add_xapi_thread_startup(xapi_thread_startup);
builder_.add_stack_size(stack_size);
builder_.add_object(object);
builder_.add_type(type);
return builder_.Finish();
@@ -90,25 +176,39 @@ inline flatbuffers::Offset<ListThreadsRequest> CreateListThreadsRequest(flatbuff
}
struct ListThreadsResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<Thread>> *thread() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Thread>> *>(
4);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
verifier.EndTable();
VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* thread */) &&
verifier.Verify(thread()) &&
verifier.VerifyVectorOfTables(thread()) && verifier.EndTable();
}
};
struct ListThreadsResponseBuilder {
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_thread(flatbuffers::Offset<
flatbuffers::Vector<flatbuffers::Offset<Thread>>> thread) {
fbb_.AddOffset(4, thread);
}
ListThreadsResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
ListThreadsResponseBuilder &operator=(const ListThreadsResponseBuilder &);
flatbuffers::Offset<ListThreadsResponse> Finish() {
auto o = flatbuffers::Offset<ListThreadsResponse>(fbb_.EndTable(start_, 0));
auto o = flatbuffers::Offset<ListThreadsResponse>(fbb_.EndTable(start_, 1));
return o;
}
};
inline flatbuffers::Offset<ListThreadsResponse> CreateListThreadsResponse(flatbuffers::FlatBufferBuilder &_fbb) {
inline flatbuffers::Offset<ListThreadsResponse> CreateListThreadsResponse(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Thread>>>
thread = 0) {
ListThreadsResponseBuilder builder_(_fbb);
builder_.add_thread(thread);
return builder_.Finish();
}