#include "LocalTargetHostInterface.h"
#include <set>
#include <stdio.h>
#include <unistd.h>
#include <image.h>
#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <system_info.h>
#include <kernel/util/KMessage.h>
#include "debug_utils.h"
#include "CoreFile.h"
#include "CoreFileDebuggerInterface.h"
#include "LocalDebuggerInterface.h"
#include "TargetHost.h"
using std::set;
LocalTargetHostInterface::LocalTargetHostInterface()
:
TargetHostInterface(),
fTargetHost(NULL),
fDataPort(-1)
{
SetName("Local");
}
LocalTargetHostInterface::~LocalTargetHostInterface()
{
Close();
if (fTargetHost != NULL)
fTargetHost->ReleaseReference();
}
status_t
LocalTargetHostInterface::Init(Settings* settings)
{
char hostname[HOST_NAME_MAX + 1];
status_t error = gethostname(hostname, sizeof(hostname));
if (error != B_OK) {
fprintf(stderr, "gethostname() failed, defaults to localhost\n");
strlcpy(hostname, "localhost", sizeof(hostname));
}
fTargetHost = new(std::nothrow) TargetHost(hostname);
if (fTargetHost == NULL)
return B_NO_MEMORY;
team_info info;
error = get_team_info(B_CURRENT_TEAM, &info);
if (error != B_OK)
return error;
char buffer[128];
snprintf(buffer, sizeof(buffer), "LocalTargetHostInterface %" B_PRId32,
info.team);
fDataPort = create_port(100, buffer);
if (fDataPort < 0)
return fDataPort;
fPortWorker = spawn_thread(_PortLoop, "Local Target Host Loop",
B_NORMAL_PRIORITY, this);
if (fPortWorker < 0)
return fPortWorker;
resume_thread(fPortWorker);
AutoLocker<TargetHost> hostLocker(fTargetHost);
error = __start_watching_system(-1,
B_WATCH_SYSTEM_TEAM_CREATION | B_WATCH_SYSTEM_TEAM_DELETION,
fDataPort, 0);
if (error != B_OK)
return error;
int32 cookie = 0;
while (get_next_team_info(&cookie, &info) == B_OK) {
error = fTargetHost->AddTeam(info);
if (error != B_OK)
return error;
}
snprintf(buffer, sizeof(buffer), "Local (%s)", hostname);
SetName(buffer);
return B_OK;
}
void
LocalTargetHostInterface::Close()
{
if (fDataPort > 0) {
__stop_watching_system(-1,
B_WATCH_SYSTEM_TEAM_CREATION | B_WATCH_SYSTEM_TEAM_DELETION,
fDataPort, 0);
delete_port(fDataPort);
fDataPort = -1;
}
if (fPortWorker > 0) {
wait_for_thread(fPortWorker, NULL);
fPortWorker = -1;
}
}
bool
LocalTargetHostInterface::IsLocal() const
{
return true;
}
bool
LocalTargetHostInterface::Connected() const
{
return true;
}
TargetHost*
LocalTargetHostInterface::GetTargetHost()
{
return fTargetHost;
}
status_t
LocalTargetHostInterface::Attach(team_id teamID, thread_id threadID,
DebuggerInterface*& _interface) const
{
if (teamID < 0 && threadID < 0)
return B_BAD_VALUE;
status_t error;
if (teamID < 0) {
thread_info threadInfo;
error = get_thread_info(threadID, &threadInfo);
if (error != B_OK)
return error;
teamID = threadInfo.team;
}
LocalDebuggerInterface* interface
= new(std::nothrow) LocalDebuggerInterface(teamID);
if (interface == NULL)
return B_NO_MEMORY;
BReference<DebuggerInterface> interfaceReference(interface, true);
error = interface->Init();
if (error != B_OK)
return error;
_interface = interface;
interfaceReference.Detach();
return B_OK;
}
status_t
LocalTargetHostInterface::CreateTeam(int commandLineArgc,
const char* const* arguments, team_id& _teamID) const
{
thread_id thread = load_program(arguments, commandLineArgc, false);
if (thread < 0)
return thread;
_teamID = thread;
return B_OK;
}
status_t
LocalTargetHostInterface::LoadCore(const char* coreFilePath,
DebuggerInterface*& _interface, thread_id& _thread) const
{
CoreFile* coreFile = new(std::nothrow) CoreFile;
if (coreFile == NULL)
return B_NO_MEMORY;
ObjectDeleter<CoreFile> coreFileDeleter(coreFile);
status_t error = coreFile->Init(coreFilePath);
if (error != B_OK)
return error;
CoreFileDebuggerInterface* interface
= new(std::nothrow) CoreFileDebuggerInterface(coreFile);
if (interface == NULL)
return B_NO_MEMORY;
coreFileDeleter.Detach();
BReference<DebuggerInterface> interfaceReference(interface, true);
error = interface->Init();
if (error != B_OK)
return error;
const CoreFileTeamInfo& teamInfo = coreFile->GetTeamInfo();
_thread = teamInfo.Id();
_interface = interface;
interfaceReference.Detach();
return B_OK;
}
status_t
LocalTargetHostInterface::FindTeamByThread(thread_id thread,
team_id& _teamID) const
{
thread_info info;
status_t error = get_thread_info(thread, &info);
if (error != B_OK)
return error;
_teamID = info.team;
return B_OK;
}
status_t
LocalTargetHostInterface::_PortLoop(void* arg)
{
LocalTargetHostInterface* interface = (LocalTargetHostInterface*)arg;
set<team_id> waitingTeams;
for (;;) {
status_t error;
bool addToWaiters;
char buffer[2048];
int32 messageCode;
team_id team;
ssize_t size = read_port_etc(interface->fDataPort, &messageCode,
buffer, sizeof(buffer), B_TIMEOUT, waitingTeams.empty()
? B_INFINITE_TIMEOUT : 20000);
if (size == B_INTERRUPTED)
continue;
else if (size == B_TIMED_OUT && !waitingTeams.empty()) {
for (set<team_id>::iterator it = waitingTeams.begin();
it != waitingTeams.end(); ++it) {
team = *it;
error = interface->_HandleTeamEvent(team,
B_TEAM_CREATED, addToWaiters);
if (error != B_OK)
continue;
else if (!addToWaiters) {
waitingTeams.erase(it);
if (waitingTeams.empty())
break;
it = waitingTeams.begin();
}
}
continue;
} else if (size < 0)
return size;
KMessage message;
size = message.SetTo(buffer);
if (size != B_OK)
continue;
if (message.What() != B_SYSTEM_OBJECT_UPDATE)
continue;
int32 opcode = 0;
if (message.FindInt32("opcode", &opcode) != B_OK)
continue;
team = -1;
if (message.FindInt32("team", &team) != B_OK)
continue;
error = interface->_HandleTeamEvent(team, opcode,
addToWaiters);
if (error != B_OK)
continue;
if (opcode == B_TEAM_CREATED && addToWaiters) {
try {
waitingTeams.insert(team);
} catch (...) {
continue;
}
}
}
return B_OK;
}
status_t
LocalTargetHostInterface::_HandleTeamEvent(team_id team, int32 opcode,
bool& addToWaiters)
{
addToWaiters = false;
AutoLocker<TargetHost> locker(fTargetHost);
switch (opcode) {
case B_TEAM_CREATED:
case B_TEAM_EXEC:
{
team_info info;
status_t error = get_team_info(team, &info);
if (error == B_BAD_TEAM_ID)
return B_OK;
else if (error != B_OK)
return error;
else {
int32 cookie = 0;
image_info imageInfo;
addToWaiters = true;
while (get_next_image_info(team, &cookie, &imageInfo)
== B_OK) {
if (imageInfo.type == B_APP_IMAGE) {
addToWaiters = false;
break;
}
}
if (addToWaiters)
return B_OK;
}
if (opcode == B_TEAM_CREATED)
fTargetHost->AddTeam(info);
else
fTargetHost->UpdateTeam(info);
break;
}
case B_TEAM_DELETED:
{
fTargetHost->RemoveTeam(team);
break;
}
default:
{
break;
}
}
return B_OK;
}
