src/apps/debugger/target_host_interface/TargetHostInterface.cpp

   1 /*
   2  * Copyright 2016, Rene Gollent, rene@gollent.com.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6 #include "TargetHostInterface.h"
   7
   8 #include <stdio.h>
   9
  10 #include <AutoLocker.h>
  11
  12 #include "DebuggerInterface.h"
  13 #include "MessageCodes.h"
  14 #include "TeamDebugger.h"
  15
  16
  17 // #pragma mark - TeamDebuggerOptions
  18
  19
  20 TeamDebuggerOptions::TeamDebuggerOptions()
  21         :
  22         requestType(TEAM_DEBUGGER_REQUEST_UNKNOWN),
  23         commandLineArgc(0),
  24         commandLineArgv(NULL),
  25         team(-1),
  26         thread(-1),
  27         settingsManager(NULL),
  28         userInterface(NULL),
  29         coreFilePath(NULL)
  30 {
  31 }
  32
  33
  34 // #pragma mark - TargetHostInterface
  35
  36
  37 TargetHostInterface::TargetHostInterface()
  38         :
  39         BLooper(),
  40         fListeners(),
  41         fTeamDebuggers(20, false)
  42 {
  43 }
  44
  45
  46 TargetHostInterface::~TargetHostInterface()
  47 {
  48         for (ListenerList::Iterator it = fListeners.GetIterator();
  49                         Listener* listener = it.Next();) {
  50                 listener->TargetHostInterfaceQuit(this);
  51         }
  52 }
  53
  54
  55 status_t
  56 TargetHostInterface::StartTeamDebugger(const TeamDebuggerOptions& options)
  57 {
  58         // we only want to stop in main for teams we're responsible for
  59         // creating ourselves.
  60         bool stopInMain = options.requestType == TEAM_DEBUGGER_REQUEST_CREATE;
  61         team_id team = options.team;
  62         thread_id thread = options.thread;
  63
  64         AutoLocker<TargetHostInterface> interfaceLocker(this);
  65         if (options.requestType == TEAM_DEBUGGER_REQUEST_CREATE) {
  66                 status_t error = CreateTeam(options.commandLineArgc,
  67                         options.commandLineArgv, team);
  68                 if (error != B_OK)
  69                         return error;
  70                 thread = team;
  71         }
  72
  73         if (options.requestType != TEAM_DEBUGGER_REQUEST_LOAD_CORE) {
  74
  75                 if (team < 0 && thread < 0)
  76                         return B_BAD_VALUE;
  77
  78                 if (team < 0) {
  79                         status_t error = FindTeamByThread(thread, team);
  80                         if (error != B_OK)
  81                                 return error;
  82                 }
  83
  84                 TeamDebugger* debugger = FindTeamDebugger(team);
  85                 if (debugger != NULL) {
  86                         debugger->Activate();
  87                         return B_OK;
  88                 }
  89         }
  90
  91         return _StartTeamDebugger(team, options, stopInMain);
  92 }
  93
  94
  95 int32
  96 TargetHostInterface::CountTeamDebuggers() const
  97 {
  98         return fTeamDebuggers.CountItems();
  99 }
 100
 101
 102 TeamDebugger*
 103 TargetHostInterface::TeamDebuggerAt(int32 index) const
 104 {
 105         return fTeamDebuggers.ItemAt(index);
 106 }
 107
 108
 109 TeamDebugger*
 110 TargetHostInterface::FindTeamDebugger(team_id team) const
 111 {
 112         for (int32 i = 0; i < fTeamDebuggers.CountItems(); i++) {
 113                 TeamDebugger* debugger = fTeamDebuggers.ItemAt(i);
 114                 if (debugger->TeamID() == team && !debugger->IsPostMortem())
 115                         return debugger;
 116         }
 117
 118         return NULL;
 119 }
 120
 121
 122 status_t
 123 TargetHostInterface::AddTeamDebugger(TeamDebugger* debugger)
 124 {
 125         if (!fTeamDebuggers.BinaryInsert(debugger, &_CompareDebuggers))
 126                 return B_NO_MEMORY;
 127
 128         return B_OK;
 129 }
 130
 131
 132 void
 133 TargetHostInterface::RemoveTeamDebugger(TeamDebugger* debugger)
 134 {
 135         for (int32 i = 0; i < fTeamDebuggers.CountItems(); i++) {
 136                 if (fTeamDebuggers.ItemAt(i) == debugger) {
 137                         fTeamDebuggers.RemoveItemAt(i);
 138                         break;
 139                 }
 140         }
 141 }
 142
 143
 144 void
 145 TargetHostInterface::AddListener(Listener* listener)
 146 {
 147         AutoLocker<TargetHostInterface> interfaceLocker(this);
 148         fListeners.Add(listener);
 149 }
 150
 151
 152 void
 153 TargetHostInterface::RemoveListener(Listener* listener)
 154 {
 155         AutoLocker<TargetHostInterface> interfaceLocker(this);
 156         fListeners.Remove(listener);
 157 }
 158
 159
 160 void
 161 TargetHostInterface::Quit()
 162 {
 163         if (fTeamDebuggers.CountItems() == 0)
 164                 BLooper::Quit();
 165 }
 166
 167
 168 void
 169 TargetHostInterface::MessageReceived(BMessage* message)
 170 {
 171         switch (message->what) {
 172         case MSG_TEAM_DEBUGGER_QUIT:
 173         {
 174                 thread_id thread;
 175                 if (message->FindInt32("thread", &thread) == B_OK)
 176                         wait_for_thread(thread, NULL);
 177                 break;
 178         }
 179         case MSG_TEAM_RESTART_REQUESTED:
 180         {
 181                 int32 teamID;
 182                 if (message->FindInt32("team", &teamID) != B_OK)
 183                         break;
 184
 185                 TeamDebugger* debugger = FindTeamDebugger(teamID);
 186
 187                 TeamDebuggerOptions options;
 188                 options.commandLineArgc = debugger->ArgumentCount();
 189                 options.commandLineArgv = debugger->Arguments();
 190                 options.settingsManager = debugger->GetSettingsManager();
 191                 status_t result = StartTeamDebugger(options);
 192                 if (result == B_OK)
 193                         debugger->PostMessage(B_QUIT_REQUESTED);
 194                 break;
 195         }
 196         default:
 197                 BLooper::MessageReceived(message);
 198                 break;
 199         }
 200 }
 201
 202
 203 void
 204 TargetHostInterface::TeamDebuggerStarted(TeamDebugger* debugger)
 205 {
 206         AutoLocker<TargetHostInterface> locker(this);
 207         AddTeamDebugger(debugger);
 208         _NotifyTeamDebuggerStarted(debugger);
 209 }
 210
 211
 212 void
 213 TargetHostInterface::TeamDebuggerRestartRequested(TeamDebugger* debugger)
 214 {
 215         BMessage message(MSG_TEAM_RESTART_REQUESTED);
 216         message.AddInt32("team", debugger->TeamID());
 217         PostMessage(&message);
 218 }
 219
 220
 221 void
 222 TargetHostInterface::TeamDebuggerQuit(TeamDebugger* debugger)
 223 {
 224         AutoLocker<TargetHostInterface> interfaceLocker(this);
 225         RemoveTeamDebugger(debugger);
 226
 227         if (debugger->Thread() >= 0) {
 228                 _NotifyTeamDebuggerQuit(debugger);
 229                 BMessage message(MSG_TEAM_DEBUGGER_QUIT);
 230                 message.AddInt32("thread", debugger->Thread());
 231                 PostMessage(&message);
 232         }
 233 }
 234
 235
 236 status_t
 237 TargetHostInterface::_StartTeamDebugger(team_id teamID,
 238         const TeamDebuggerOptions& options, bool stopInMain)
 239 {
 240         UserInterface* userInterface = options.userInterface;
 241         if (userInterface == NULL) {
 242                 fprintf(stderr, "Error: Requested team debugger start without "
 243                         "valid user interface!\n");
 244                 return B_BAD_VALUE;
 245         }
 246
 247         thread_id threadID = options.thread;
 248         if (options.commandLineArgv != NULL)
 249                 threadID = teamID;
 250
 251         DebuggerInterface* interface = NULL;
 252         TeamDebugger* debugger = NULL;
 253         status_t error = B_OK;
 254         if (options.requestType != TEAM_DEBUGGER_REQUEST_LOAD_CORE) {
 255                 error = Attach(teamID, options.thread, interface);
 256                 if (error != B_OK) {
 257                         fprintf(stderr, "Error: Failed to attach to team %" B_PRId32
 258                                 ": %s!\n", teamID, strerror(error));
 259                         return error;
 260                 }
 261         } else {
 262                 error = LoadCore(options.coreFilePath, interface, threadID);
 263                 if (error != B_OK) {
 264                         fprintf(stderr, "Error: Failed to load core file '%s': %s!\n",
 265                                 options.coreFilePath, strerror(error));
 266                         return error;
 267                 }
 268         }
 269
 270         BReference<DebuggerInterface> debuggerInterfaceReference(interface,
 271                 true);
 272         debugger = new(std::nothrow) TeamDebugger(this, userInterface,
 273                 options.settingsManager);
 274         if (debugger != NULL) {
 275                 error = debugger->Init(interface, threadID,
 276                         options.commandLineArgc, options.commandLineArgv, stopInMain);
 277         }
 278
 279         if (error != B_OK) {
 280                 printf("Error: debugger for team %" B_PRId32 " on interface %s failed"
 281                         " to init: %s!\n", interface->TeamID(), Name(), strerror(error));
 282                 delete debugger;
 283                 debugger = NULL;
 284         } else {
 285                 printf("debugger for team %" B_PRId32 " on interface %s created and"
 286                         " initialized successfully!\n", interface->TeamID(), Name());
 287         }
 288
 289         return error;
 290 }
 291
 292
 293 void
 294 TargetHostInterface::_NotifyTeamDebuggerStarted(TeamDebugger* debugger)
 295 {
 296         for (ListenerList::Iterator it = fListeners.GetIterator();
 297                         Listener* listener = it.Next();) {
 298                 listener->TeamDebuggerStarted(debugger);
 299         }
 300 }
 301
 302
 303 void
 304 TargetHostInterface::_NotifyTeamDebuggerQuit(TeamDebugger* debugger)
 305 {
 306         for (ListenerList::Iterator it = fListeners.GetIterator();
 307                         Listener* listener = it.Next();) {
 308                 listener->TeamDebuggerQuit(debugger);
 309         }
 310 }
 311
 312
 313 /*static*/ int
 314 TargetHostInterface::_CompareDebuggers(const TeamDebugger* a,
 315         const TeamDebugger* b)
 316 {
 317         return a->TeamID() < b->TeamID() ? -1 : 1;
 318 }
 319
 320
 321 // #pragma mark - TargetHostInterface::Listener
 322
 323
 324 TargetHostInterface::Listener::~Listener()
 325 {
 326 }
 327
 328
 329 void
 330 TargetHostInterface::Listener::TeamDebuggerStarted(TeamDebugger* debugger)
 331 {
 332 }
 333
 334
 335 void
 336 TargetHostInterface::Listener::TeamDebuggerQuit(TeamDebugger* debugger)
 337 {
 338 }
 339
 340
 341 void
 342 TargetHostInterface::Listener::TargetHostInterfaceQuit(
 343         TargetHostInterface* interface)
 344 {
 345 }