src/kits/debugger/target_host_interface/local/LocalTargetHostInterface.cpp

   1 /*
   2  * Copyright 2016, Rene Gollent, rene@gollent.com.
   3  * Copyright 2016, Ingo Weinhold, ingo_weinhold@gmx.de.
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7 #include "LocalTargetHostInterface.h"
   8
   9 #include <set>
  10
  11 #include <stdio.h>
  12 #include <unistd.h>
  13
  14 #include <image.h>
  15
  16 #include <AutoDeleter.h>
  17 #include <AutoLocker.h>
  18 #include <system_info.h>
  19 #include <util/KMessage.h>
  20
  21 #include "debug_utils.h"
  22
  23 #include "CoreFile.h"
  24 #include "CoreFileDebuggerInterface.h"
  25 #include "LocalDebuggerInterface.h"
  26 #include "TargetHost.h"
  27
  28 using std::set;
  29
  30 LocalTargetHostInterface::LocalTargetHostInterface()
  31         :
  32         TargetHostInterface(),
  33         fTargetHost(NULL),
  34         fDataPort(-1)
  35 {
  36         SetName("Local");
  37 }
  38
  39
  40 LocalTargetHostInterface::~LocalTargetHostInterface()
  41 {
  42         Close();
  43
  44         if (fTargetHost != NULL)
  45                 fTargetHost->ReleaseReference();
  46 }
  47
  48
  49 status_t
  50 LocalTargetHostInterface::Init(Settings* settings)
  51 {
  52         char hostname[HOST_NAME_MAX + 1];
  53         status_t error = gethostname(hostname, sizeof(hostname));
  54         if (error != B_OK)
  55                 return error;
  56
  57         fTargetHost = new(std::nothrow) TargetHost(hostname);
  58         if (fTargetHost == NULL)
  59                 return B_NO_MEMORY;
  60
  61         team_info info;
  62         error = get_team_info(B_CURRENT_TEAM, &info);
  63         if (error != B_OK)
  64                 return error;
  65
  66         char buffer[128];
  67         snprintf(buffer, sizeof(buffer), "LocalTargetHostInterface %" B_PRId32,
  68                 info.team);
  69
  70         fDataPort = create_port(100, buffer);
  71         if (fDataPort < 0)
  72                 return fDataPort;
  73
  74         fPortWorker = spawn_thread(_PortLoop, "Local Target Host Loop",
  75                 B_NORMAL_PRIORITY, this);
  76         if (fPortWorker < 0)
  77                 return fPortWorker;
  78
  79         resume_thread(fPortWorker);
  80
  81         AutoLocker<TargetHost> hostLocker(fTargetHost);
  82
  83         error = __start_watching_system(-1,
  84                 B_WATCH_SYSTEM_TEAM_CREATION | B_WATCH_SYSTEM_TEAM_DELETION,
  85                 fDataPort, 0);
  86         if (error != B_OK)
  87                 return error;
  88
  89         int32 cookie = 0;
  90         while (get_next_team_info(&cookie, &info) == B_OK) {
  91                 error = fTargetHost->AddTeam(info);
  92                 if (error != B_OK)
  93                         return error;
  94         }
  95
  96         snprintf(buffer, sizeof(buffer), "Local (%s)", hostname);
  97         SetName(buffer);
  98
  99         return B_OK;
 100 }
 101
 102
 103 void
 104 LocalTargetHostInterface::Close()
 105 {
 106         if (fDataPort > 0) {
 107                 __stop_watching_system(-1,
 108                         B_WATCH_SYSTEM_TEAM_CREATION | B_WATCH_SYSTEM_TEAM_DELETION,
 109                         fDataPort, 0);
 110
 111                 delete_port(fDataPort);
 112                 fDataPort = -1;
 113         }
 114
 115         if (fPortWorker > 0) {
 116                 wait_for_thread(fPortWorker, NULL);
 117                 fPortWorker = -1;
 118         }
 119 }
 120
 121
 122 bool
 123 LocalTargetHostInterface::IsLocal() const
 124 {
 125         return true;
 126 }
 127
 128
 129 bool
 130 LocalTargetHostInterface::Connected() const
 131 {
 132         return true;
 133 }
 134
 135
 136 TargetHost*
 137 LocalTargetHostInterface::GetTargetHost()
 138 {
 139         return fTargetHost;
 140 }
 141
 142
 143 status_t
 144 LocalTargetHostInterface::Attach(team_id teamID, thread_id threadID,
 145         DebuggerInterface*& _interface) const
 146 {
 147         if (teamID < 0 && threadID < 0)
 148                 return B_BAD_VALUE;
 149
 150         status_t error;
 151         if (teamID < 0) {
 152                 thread_info threadInfo;
 153                 error = get_thread_info(threadID, &threadInfo);
 154                 if (error != B_OK)
 155                         return error;
 156
 157                 teamID = threadInfo.team;
 158         }
 159
 160         LocalDebuggerInterface* interface
 161                 = new(std::nothrow) LocalDebuggerInterface(teamID);
 162         if (interface == NULL)
 163                 return B_NO_MEMORY;
 164
 165         BReference<DebuggerInterface> interfaceReference(interface, true);
 166         error = interface->Init();
 167         if (error != B_OK)
 168                 return error;
 169
 170         _interface = interface;
 171         interfaceReference.Detach();
 172         return B_OK;
 173 }
 174
 175
 176 status_t
 177 LocalTargetHostInterface::CreateTeam(int commandLineArgc,
 178         const char* const* arguments, team_id& _teamID) const
 179 {
 180         thread_id thread = load_program(arguments, commandLineArgc, false);
 181         if (thread < 0)
 182                 return thread;
 183
 184         // main thread ID == team ID.
 185         _teamID = thread;
 186         return B_OK;
 187 }
 188
 189
 190 status_t
 191 LocalTargetHostInterface::LoadCore(const char* coreFilePath,
 192         DebuggerInterface*& _interface, thread_id& _thread) const
 193 {
 194         // load the core file
 195         CoreFile* coreFile = new(std::nothrow) CoreFile;
 196         if (coreFile == NULL)
 197                 return B_NO_MEMORY;
 198         ObjectDeleter<CoreFile> coreFileDeleter(coreFile);
 199
 200         status_t error = coreFile->Init(coreFilePath);
 201         if (error != B_OK)
 202                 return error;
 203
 204         // create the debugger interface
 205         CoreFileDebuggerInterface* interface
 206                 = new(std::nothrow) CoreFileDebuggerInterface(coreFile);
 207         if (interface == NULL)
 208                 return B_NO_MEMORY;
 209         coreFileDeleter.Detach();
 210
 211         BReference<DebuggerInterface> interfaceReference(interface, true);
 212         error = interface->Init();
 213         if (error != B_OK)
 214                 return error;
 215
 216         const CoreFileTeamInfo& teamInfo = coreFile->GetTeamInfo();
 217         _thread = teamInfo.Id();
 218         _interface = interface;
 219         interfaceReference.Detach();
 220
 221         return B_OK;
 222 }
 223
 224
 225 status_t
 226 LocalTargetHostInterface::FindTeamByThread(thread_id thread,
 227         team_id& _teamID) const
 228 {
 229         thread_info info;
 230         status_t error = get_thread_info(thread, &info);
 231         if (error != B_OK)
 232                 return error;
 233
 234         _teamID = info.team;
 235         return B_OK;
 236 }
 237
 238
 239 status_t
 240 LocalTargetHostInterface::_PortLoop(void* arg)
 241 {
 242         LocalTargetHostInterface* interface = (LocalTargetHostInterface*)arg;
 243         set<team_id> waitingTeams;
 244
 245         for (;;) {
 246                 status_t error;
 247                 bool addToWaiters;
 248                 char buffer[2048];
 249                 int32 messageCode;
 250                 team_id team;
 251
 252                 ssize_t size = read_port_etc(interface->fDataPort, &messageCode,
 253                         buffer, sizeof(buffer), B_TIMEOUT, waitingTeams.empty()
 254                                 ? B_INFINITE_TIMEOUT : 20000);
 255                 if (size == B_INTERRUPTED)
 256                         continue;
 257                 else if (size == B_TIMED_OUT && !waitingTeams.empty()) {
 258                         for (set<team_id>::iterator it = waitingTeams.begin();
 259                                 it != waitingTeams.end(); ++it) {
 260                                 team = *it;
 261                                 error = interface->_HandleTeamEvent(team,
 262                                         B_TEAM_CREATED, addToWaiters);
 263                                 if (error != B_OK)
 264                                         continue;
 265                                 else if (!addToWaiters) {
 266                                         waitingTeams.erase(it);
 267                                         if (waitingTeams.empty())
 268                                                 break;
 269                                         it = waitingTeams.begin();
 270                                 }
 271                         }
 272                         continue;
 273                 } else if (size < 0)
 274                         return size;
 275
 276                 KMessage message;
 277                 size = message.SetTo(buffer);
 278                 if (size != B_OK)
 279                         continue;
 280
 281                 if (message.What() != B_SYSTEM_OBJECT_UPDATE)
 282                         continue;
 283
 284                 int32 opcode = 0;
 285                 if (message.FindInt32("opcode", &opcode) != B_OK)
 286                         continue;
 287
 288                 team = -1;
 289                 if (message.FindInt32("team", &team) != B_OK)
 290                         continue;
 291
 292                 error = interface->_HandleTeamEvent(team, opcode,
 293                         addToWaiters);
 294                 if (error != B_OK)
 295                         continue;
 296                 if (opcode == B_TEAM_CREATED && addToWaiters) {
 297                         try {
 298                                 waitingTeams.insert(team);
 299                         } catch (...) {
 300                                 continue;
 301                         }
 302                 }
 303         }
 304
 305         return B_OK;
 306 }
 307
 308
 309 status_t
 310 LocalTargetHostInterface::_HandleTeamEvent(team_id team, int32 opcode,
 311         bool& addToWaiters)
 312 {
 313         addToWaiters = false;
 314         AutoLocker<TargetHost> locker(fTargetHost);
 315         switch (opcode) {
 316                 case B_TEAM_CREATED:
 317                 case B_TEAM_EXEC:
 318                 {
 319                         team_info info;
 320                         status_t error = get_team_info(team, &info);
 321                         // this team is already gone, no point in sending a notification
 322                         if (error == B_BAD_TEAM_ID)
 323                                 return B_OK;
 324                         else if (error != B_OK)
 325                                 return error;
 326                         else {
 327                                 int32 cookie = 0;
 328                                 image_info imageInfo;
 329                                 addToWaiters = true;
 330                                 while (get_next_image_info(team, &cookie, &imageInfo)
 331                                         == B_OK) {
 332                                         if (imageInfo.type == B_APP_IMAGE) {
 333                                                 addToWaiters = false;
 334                                                 break;
 335                                         }
 336                                 }
 337                                 if (addToWaiters)
 338                                         return B_OK;
 339                         }
 340
 341                         if (opcode == B_TEAM_CREATED)
 342                                 fTargetHost->AddTeam(info);
 343                         else
 344                                 fTargetHost->UpdateTeam(info);
 345                         break;
 346                 }
 347
 348                 case B_TEAM_DELETED:
 349                 {
 350                         fTargetHost->RemoveTeam(team);
 351                         break;
 352                 }
 353
 354                 default:
 355                 {
 356                         break;
 357                 }
 358         }
 359
 360         return B_OK;
 361 }