1 //===-- SBProcess.cpp -------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/API/SBProcess.h" 11 12 // C Includes 13 #include <inttypes.h> 14 15 #include "lldb/lldb-defines.h" 16 #include "lldb/lldb-types.h" 17 18 #include "lldb/Core/Debugger.h" 19 #include "lldb/Core/Module.h" 20 #include "lldb/Core/PluginManager.h" 21 #include "lldb/Core/State.h" 22 #include "lldb/Core/StreamFile.h" 23 #include "lldb/Target/MemoryRegionInfo.h" 24 #include "lldb/Target/Process.h" 25 #include "lldb/Target/RegisterContext.h" 26 #include "lldb/Target/SystemRuntime.h" 27 #include "lldb/Target/Target.h" 28 #include "lldb/Target/Thread.h" 29 #include "lldb/Utility/Args.h" 30 #include "lldb/Utility/Log.h" 31 #include "lldb/Utility/Stream.h" 32 33 // Project includes 34 35 #include "lldb/API/SBBroadcaster.h" 36 #include "lldb/API/SBCommandReturnObject.h" 37 #include "lldb/API/SBDebugger.h" 38 #include "lldb/API/SBEvent.h" 39 #include "lldb/API/SBFileSpec.h" 40 #include "lldb/API/SBMemoryRegionInfo.h" 41 #include "lldb/API/SBMemoryRegionInfoList.h" 42 #include "lldb/API/SBStream.h" 43 #include "lldb/API/SBStringList.h" 44 #include "lldb/API/SBStructuredData.h" 45 #include "lldb/API/SBThread.h" 46 #include "lldb/API/SBThreadCollection.h" 47 #include "lldb/API/SBTrace.h" 48 #include "lldb/API/SBTraceOptions.h" 49 #include "lldb/API/SBUnixSignals.h" 50 51 using namespace lldb; 52 using namespace lldb_private; 53 54 SBProcess::SBProcess() : m_opaque_wp() {} 55 56 //---------------------------------------------------------------------- 57 // SBProcess constructor 58 //---------------------------------------------------------------------- 59 60 SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) {} 61 62 SBProcess::SBProcess(const lldb::ProcessSP &process_sp) 63 : m_opaque_wp(process_sp) {} 64 65 const SBProcess &SBProcess::operator=(const SBProcess &rhs) { 66 if (this != &rhs) 67 m_opaque_wp = rhs.m_opaque_wp; 68 return *this; 69 } 70 71 //---------------------------------------------------------------------- 72 // Destructor 73 //---------------------------------------------------------------------- 74 SBProcess::~SBProcess() {} 75 76 const char *SBProcess::GetBroadcasterClassName() { 77 return Process::GetStaticBroadcasterClass().AsCString(); 78 } 79 80 const char *SBProcess::GetPluginName() { 81 ProcessSP process_sp(GetSP()); 82 if (process_sp) { 83 return process_sp->GetPluginName().GetCString(); 84 } 85 return "<Unknown>"; 86 } 87 88 const char *SBProcess::GetShortPluginName() { 89 ProcessSP process_sp(GetSP()); 90 if (process_sp) { 91 return process_sp->GetPluginName().GetCString(); 92 } 93 return "<Unknown>"; 94 } 95 96 lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); } 97 98 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } 99 100 void SBProcess::Clear() { m_opaque_wp.reset(); } 101 102 bool SBProcess::IsValid() const { 103 ProcessSP process_sp(m_opaque_wp.lock()); 104 return ((bool)process_sp && process_sp->IsValid()); 105 } 106 107 bool SBProcess::RemoteLaunch(char const **argv, char const **envp, 108 const char *stdin_path, const char *stdout_path, 109 const char *stderr_path, 110 const char *working_directory, 111 uint32_t launch_flags, bool stop_at_entry, 112 lldb::SBError &error) { 113 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 114 if (log) 115 log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, " 116 "stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, " 117 "stop_at_entry=%i, &error (%p))...", 118 static_cast<void *>(m_opaque_wp.lock().get()), 119 static_cast<void *>(argv), static_cast<void *>(envp), 120 stdin_path ? stdin_path : "NULL", 121 stdout_path ? stdout_path : "NULL", 122 stderr_path ? stderr_path : "NULL", 123 working_directory ? working_directory : "NULL", launch_flags, 124 stop_at_entry, static_cast<void *>(error.get())); 125 126 ProcessSP process_sp(GetSP()); 127 if (process_sp) { 128 std::lock_guard<std::recursive_mutex> guard( 129 process_sp->GetTarget().GetAPIMutex()); 130 if (process_sp->GetState() == eStateConnected) { 131 if (stop_at_entry) 132 launch_flags |= eLaunchFlagStopAtEntry; 133 ProcessLaunchInfo launch_info( 134 FileSpec{stdin_path, false}, FileSpec{stdout_path, false}, 135 FileSpec{stderr_path, false}, FileSpec{working_directory, false}, 136 launch_flags); 137 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 138 if (exe_module) 139 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 140 if (argv) 141 launch_info.GetArguments().AppendArguments(argv); 142 if (envp) 143 launch_info.GetEnvironment() = Environment(envp); 144 error.SetError(process_sp->Launch(launch_info)); 145 } else { 146 error.SetErrorString("must be in eStateConnected to call RemoteLaunch"); 147 } 148 } else { 149 error.SetErrorString("unable to attach pid"); 150 } 151 152 if (log) { 153 SBStream sstr; 154 error.GetDescription(sstr); 155 log->Printf("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", 156 static_cast<void *>(process_sp.get()), 157 static_cast<void *>(error.get()), sstr.GetData()); 158 } 159 160 return error.Success(); 161 } 162 163 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, 164 lldb::SBError &error) { 165 ProcessSP process_sp(GetSP()); 166 if (process_sp) { 167 std::lock_guard<std::recursive_mutex> guard( 168 process_sp->GetTarget().GetAPIMutex()); 169 if (process_sp->GetState() == eStateConnected) { 170 ProcessAttachInfo attach_info; 171 attach_info.SetProcessID(pid); 172 error.SetError(process_sp->Attach(attach_info)); 173 } else { 174 error.SetErrorString( 175 "must be in eStateConnected to call RemoteAttachToProcessWithID"); 176 } 177 } else { 178 error.SetErrorString("unable to attach pid"); 179 } 180 181 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 182 if (log) { 183 SBStream sstr; 184 error.GetDescription(sstr); 185 log->Printf("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64 186 ") => SBError (%p): %s", 187 static_cast<void *>(process_sp.get()), pid, 188 static_cast<void *>(error.get()), sstr.GetData()); 189 } 190 191 return error.Success(); 192 } 193 194 uint32_t SBProcess::GetNumThreads() { 195 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 196 197 uint32_t num_threads = 0; 198 ProcessSP process_sp(GetSP()); 199 if (process_sp) { 200 Process::StopLocker stop_locker; 201 202 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 203 std::lock_guard<std::recursive_mutex> guard( 204 process_sp->GetTarget().GetAPIMutex()); 205 num_threads = process_sp->GetThreadList().GetSize(can_update); 206 } 207 208 if (log) 209 log->Printf("SBProcess(%p)::GetNumThreads () => %d", 210 static_cast<void *>(process_sp.get()), num_threads); 211 212 return num_threads; 213 } 214 215 SBThread SBProcess::GetSelectedThread() const { 216 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 217 218 SBThread sb_thread; 219 ThreadSP thread_sp; 220 ProcessSP process_sp(GetSP()); 221 if (process_sp) { 222 std::lock_guard<std::recursive_mutex> guard( 223 process_sp->GetTarget().GetAPIMutex()); 224 thread_sp = process_sp->GetThreadList().GetSelectedThread(); 225 sb_thread.SetThread(thread_sp); 226 } 227 228 if (log) 229 log->Printf("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", 230 static_cast<void *>(process_sp.get()), 231 static_cast<void *>(thread_sp.get())); 232 233 return sb_thread; 234 } 235 236 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, 237 lldb::addr_t context) { 238 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 239 240 SBThread sb_thread; 241 ThreadSP thread_sp; 242 ProcessSP process_sp(GetSP()); 243 if (process_sp) { 244 std::lock_guard<std::recursive_mutex> guard( 245 process_sp->GetTarget().GetAPIMutex()); 246 thread_sp = process_sp->CreateOSPluginThread(tid, context); 247 sb_thread.SetThread(thread_sp); 248 } 249 250 if (log) 251 log->Printf("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64 252 ", context=0x%" PRIx64 ") => SBThread(%p)", 253 static_cast<void *>(process_sp.get()), tid, context, 254 static_cast<void *>(thread_sp.get())); 255 256 return sb_thread; 257 } 258 259 SBTarget SBProcess::GetTarget() const { 260 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 261 262 SBTarget sb_target; 263 TargetSP target_sp; 264 ProcessSP process_sp(GetSP()); 265 if (process_sp) { 266 target_sp = process_sp->GetTarget().shared_from_this(); 267 sb_target.SetSP(target_sp); 268 } 269 270 if (log) 271 log->Printf("SBProcess(%p)::GetTarget () => SBTarget(%p)", 272 static_cast<void *>(process_sp.get()), 273 static_cast<void *>(target_sp.get())); 274 275 return sb_target; 276 } 277 278 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { 279 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 280 281 size_t ret_val = 0; 282 ProcessSP process_sp(GetSP()); 283 if (process_sp) { 284 Status error; 285 ret_val = process_sp->PutSTDIN(src, src_len, error); 286 } 287 288 if (log) 289 log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64 290 ") => %" PRIu64, 291 static_cast<void *>(process_sp.get()), src, 292 static_cast<uint64_t>(src_len), static_cast<uint64_t>(ret_val)); 293 294 return ret_val; 295 } 296 297 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { 298 size_t bytes_read = 0; 299 ProcessSP process_sp(GetSP()); 300 if (process_sp) { 301 Status error; 302 bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); 303 } 304 305 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 306 if (log) 307 log->Printf( 308 "SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64 309 ") => %" PRIu64, 310 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 311 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 312 313 return bytes_read; 314 } 315 316 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { 317 size_t bytes_read = 0; 318 ProcessSP process_sp(GetSP()); 319 if (process_sp) { 320 Status error; 321 bytes_read = process_sp->GetSTDERR(dst, dst_len, error); 322 } 323 324 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 325 if (log) 326 log->Printf( 327 "SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64 328 ") => %" PRIu64, 329 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 330 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 331 332 return bytes_read; 333 } 334 335 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { 336 size_t bytes_read = 0; 337 ProcessSP process_sp(GetSP()); 338 if (process_sp) { 339 Status error; 340 bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); 341 } 342 343 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 344 if (log) 345 log->Printf( 346 "SBProcess(%p)::GetAsyncProfileData (dst=\"%.*s\", dst_len=%" PRIu64 347 ") => %" PRIu64, 348 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 349 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 350 351 return bytes_read; 352 } 353 354 lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, 355 lldb::SBError &error) { 356 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 357 ProcessSP process_sp(GetSP()); 358 error.Clear(); 359 SBTrace trace_instance; 360 trace_instance.SetSP(process_sp); 361 lldb::user_id_t uid = LLDB_INVALID_UID; 362 363 if (!process_sp) { 364 error.SetErrorString("invalid process"); 365 } else { 366 uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); 367 trace_instance.SetTraceUID(uid); 368 LLDB_LOG(log, "SBProcess::returned uid - {0}", uid); 369 } 370 return trace_instance; 371 } 372 373 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { 374 if (out == NULL) 375 return; 376 377 ProcessSP process_sp(GetSP()); 378 if (process_sp) { 379 const StateType event_state = SBProcess::GetStateFromEvent(event); 380 char message[1024]; 381 int message_len = ::snprintf( 382 message, sizeof(message), "Process %" PRIu64 " %s\n", 383 process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 384 385 if (message_len > 0) 386 ::fwrite(message, 1, message_len, out); 387 } 388 } 389 390 void SBProcess::AppendEventStateReport(const SBEvent &event, 391 SBCommandReturnObject &result) { 392 ProcessSP process_sp(GetSP()); 393 if (process_sp) { 394 const StateType event_state = SBProcess::GetStateFromEvent(event); 395 char message[1024]; 396 ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n", 397 process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 398 399 result.AppendMessage(message); 400 } 401 } 402 403 bool SBProcess::SetSelectedThread(const SBThread &thread) { 404 ProcessSP process_sp(GetSP()); 405 if (process_sp) { 406 std::lock_guard<std::recursive_mutex> guard( 407 process_sp->GetTarget().GetAPIMutex()); 408 return process_sp->GetThreadList().SetSelectedThreadByID( 409 thread.GetThreadID()); 410 } 411 return false; 412 } 413 414 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { 415 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 416 417 bool ret_val = false; 418 ProcessSP process_sp(GetSP()); 419 if (process_sp) { 420 std::lock_guard<std::recursive_mutex> guard( 421 process_sp->GetTarget().GetAPIMutex()); 422 ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid); 423 } 424 425 if (log) 426 log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64 427 ") => %s", 428 static_cast<void *>(process_sp.get()), tid, 429 (ret_val ? "true" : "false")); 430 431 return ret_val; 432 } 433 434 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { 435 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 436 437 bool ret_val = false; 438 ProcessSP process_sp(GetSP()); 439 if (process_sp) { 440 std::lock_guard<std::recursive_mutex> guard( 441 process_sp->GetTarget().GetAPIMutex()); 442 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id); 443 } 444 445 if (log) 446 log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s", 447 static_cast<void *>(process_sp.get()), index_id, 448 (ret_val ? "true" : "false")); 449 450 return ret_val; 451 } 452 453 SBThread SBProcess::GetThreadAtIndex(size_t index) { 454 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 455 456 SBThread sb_thread; 457 ThreadSP thread_sp; 458 ProcessSP process_sp(GetSP()); 459 if (process_sp) { 460 Process::StopLocker stop_locker; 461 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 462 std::lock_guard<std::recursive_mutex> guard( 463 process_sp->GetTarget().GetAPIMutex()); 464 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update); 465 sb_thread.SetThread(thread_sp); 466 } 467 468 if (log) 469 log->Printf("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)", 470 static_cast<void *>(process_sp.get()), 471 static_cast<uint32_t>(index), 472 static_cast<void *>(thread_sp.get())); 473 474 return sb_thread; 475 } 476 477 uint32_t SBProcess::GetNumQueues() { 478 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 479 480 uint32_t num_queues = 0; 481 ProcessSP process_sp(GetSP()); 482 if (process_sp) { 483 Process::StopLocker stop_locker; 484 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 485 std::lock_guard<std::recursive_mutex> guard( 486 process_sp->GetTarget().GetAPIMutex()); 487 num_queues = process_sp->GetQueueList().GetSize(); 488 } 489 } 490 491 if (log) 492 log->Printf("SBProcess(%p)::GetNumQueues () => %d", 493 static_cast<void *>(process_sp.get()), num_queues); 494 495 return num_queues; 496 } 497 498 SBQueue SBProcess::GetQueueAtIndex(size_t index) { 499 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 500 501 SBQueue sb_queue; 502 QueueSP queue_sp; 503 ProcessSP process_sp(GetSP()); 504 if (process_sp) { 505 Process::StopLocker stop_locker; 506 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 507 std::lock_guard<std::recursive_mutex> guard( 508 process_sp->GetTarget().GetAPIMutex()); 509 queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index); 510 sb_queue.SetQueue(queue_sp); 511 } 512 } 513 514 if (log) 515 log->Printf("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)", 516 static_cast<void *>(process_sp.get()), 517 static_cast<uint32_t>(index), 518 static_cast<void *>(queue_sp.get())); 519 520 return sb_queue; 521 } 522 523 uint32_t SBProcess::GetStopID(bool include_expression_stops) { 524 ProcessSP process_sp(GetSP()); 525 if (process_sp) { 526 std::lock_guard<std::recursive_mutex> guard( 527 process_sp->GetTarget().GetAPIMutex()); 528 if (include_expression_stops) 529 return process_sp->GetStopID(); 530 else 531 return process_sp->GetLastNaturalStopID(); 532 } 533 return 0; 534 } 535 536 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { 537 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 538 539 SBEvent sb_event; 540 EventSP event_sp; 541 ProcessSP process_sp(GetSP()); 542 if (process_sp) { 543 std::lock_guard<std::recursive_mutex> guard( 544 process_sp->GetTarget().GetAPIMutex()); 545 event_sp = process_sp->GetStopEventForStopID(stop_id); 546 sb_event.reset(event_sp); 547 } 548 549 if (log) 550 log->Printf("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32 551 ") => SBEvent(%p)", 552 static_cast<void *>(process_sp.get()), stop_id, 553 static_cast<void *>(event_sp.get())); 554 555 return sb_event; 556 } 557 558 StateType SBProcess::GetState() { 559 560 StateType ret_val = eStateInvalid; 561 ProcessSP process_sp(GetSP()); 562 if (process_sp) { 563 std::lock_guard<std::recursive_mutex> guard( 564 process_sp->GetTarget().GetAPIMutex()); 565 ret_val = process_sp->GetState(); 566 } 567 568 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 569 if (log) 570 log->Printf("SBProcess(%p)::GetState () => %s", 571 static_cast<void *>(process_sp.get()), 572 lldb_private::StateAsCString(ret_val)); 573 574 return ret_val; 575 } 576 577 int SBProcess::GetExitStatus() { 578 int exit_status = 0; 579 ProcessSP process_sp(GetSP()); 580 if (process_sp) { 581 std::lock_guard<std::recursive_mutex> guard( 582 process_sp->GetTarget().GetAPIMutex()); 583 exit_status = process_sp->GetExitStatus(); 584 } 585 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 586 if (log) 587 log->Printf("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)", 588 static_cast<void *>(process_sp.get()), exit_status, 589 exit_status); 590 591 return exit_status; 592 } 593 594 const char *SBProcess::GetExitDescription() { 595 const char *exit_desc = NULL; 596 ProcessSP process_sp(GetSP()); 597 if (process_sp) { 598 std::lock_guard<std::recursive_mutex> guard( 599 process_sp->GetTarget().GetAPIMutex()); 600 exit_desc = process_sp->GetExitDescription(); 601 } 602 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 603 if (log) 604 log->Printf("SBProcess(%p)::GetExitDescription () => %s", 605 static_cast<void *>(process_sp.get()), exit_desc); 606 return exit_desc; 607 } 608 609 lldb::pid_t SBProcess::GetProcessID() { 610 lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; 611 ProcessSP process_sp(GetSP()); 612 if (process_sp) 613 ret_val = process_sp->GetID(); 614 615 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 616 if (log) 617 log->Printf("SBProcess(%p)::GetProcessID () => %" PRIu64, 618 static_cast<void *>(process_sp.get()), ret_val); 619 620 return ret_val; 621 } 622 623 uint32_t SBProcess::GetUniqueID() { 624 uint32_t ret_val = 0; 625 ProcessSP process_sp(GetSP()); 626 if (process_sp) 627 ret_val = process_sp->GetUniqueID(); 628 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 629 if (log) 630 log->Printf("SBProcess(%p)::GetUniqueID () => %" PRIu32, 631 static_cast<void *>(process_sp.get()), ret_val); 632 return ret_val; 633 } 634 635 ByteOrder SBProcess::GetByteOrder() const { 636 ByteOrder byteOrder = eByteOrderInvalid; 637 ProcessSP process_sp(GetSP()); 638 if (process_sp) 639 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); 640 641 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 642 if (log) 643 log->Printf("SBProcess(%p)::GetByteOrder () => %d", 644 static_cast<void *>(process_sp.get()), byteOrder); 645 646 return byteOrder; 647 } 648 649 uint32_t SBProcess::GetAddressByteSize() const { 650 uint32_t size = 0; 651 ProcessSP process_sp(GetSP()); 652 if (process_sp) 653 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); 654 655 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 656 if (log) 657 log->Printf("SBProcess(%p)::GetAddressByteSize () => %d", 658 static_cast<void *>(process_sp.get()), size); 659 660 return size; 661 } 662 663 SBError SBProcess::Continue() { 664 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 665 666 SBError sb_error; 667 ProcessSP process_sp(GetSP()); 668 669 if (log) 670 log->Printf("SBProcess(%p)::Continue ()...", 671 static_cast<void *>(process_sp.get())); 672 673 if (process_sp) { 674 std::lock_guard<std::recursive_mutex> guard( 675 process_sp->GetTarget().GetAPIMutex()); 676 677 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution()) 678 sb_error.ref() = process_sp->Resume(); 679 else 680 sb_error.ref() = process_sp->ResumeSynchronous(NULL); 681 } else 682 sb_error.SetErrorString("SBProcess is invalid"); 683 684 if (log) { 685 SBStream sstr; 686 sb_error.GetDescription(sstr); 687 log->Printf("SBProcess(%p)::Continue () => SBError (%p): %s", 688 static_cast<void *>(process_sp.get()), 689 static_cast<void *>(sb_error.get()), sstr.GetData()); 690 } 691 692 return sb_error; 693 } 694 695 SBError SBProcess::Destroy() { 696 SBError sb_error; 697 ProcessSP process_sp(GetSP()); 698 if (process_sp) { 699 std::lock_guard<std::recursive_mutex> guard( 700 process_sp->GetTarget().GetAPIMutex()); 701 sb_error.SetError(process_sp->Destroy(false)); 702 } else 703 sb_error.SetErrorString("SBProcess is invalid"); 704 705 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 706 if (log) { 707 SBStream sstr; 708 sb_error.GetDescription(sstr); 709 log->Printf("SBProcess(%p)::Destroy () => SBError (%p): %s", 710 static_cast<void *>(process_sp.get()), 711 static_cast<void *>(sb_error.get()), sstr.GetData()); 712 } 713 714 return sb_error; 715 } 716 717 SBError SBProcess::Stop() { 718 SBError sb_error; 719 ProcessSP process_sp(GetSP()); 720 if (process_sp) { 721 std::lock_guard<std::recursive_mutex> guard( 722 process_sp->GetTarget().GetAPIMutex()); 723 sb_error.SetError(process_sp->Halt()); 724 } else 725 sb_error.SetErrorString("SBProcess is invalid"); 726 727 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 728 if (log) { 729 SBStream sstr; 730 sb_error.GetDescription(sstr); 731 log->Printf("SBProcess(%p)::Stop () => SBError (%p): %s", 732 static_cast<void *>(process_sp.get()), 733 static_cast<void *>(sb_error.get()), sstr.GetData()); 734 } 735 736 return sb_error; 737 } 738 739 SBError SBProcess::Kill() { 740 SBError sb_error; 741 ProcessSP process_sp(GetSP()); 742 if (process_sp) { 743 std::lock_guard<std::recursive_mutex> guard( 744 process_sp->GetTarget().GetAPIMutex()); 745 sb_error.SetError(process_sp->Destroy(true)); 746 } else 747 sb_error.SetErrorString("SBProcess is invalid"); 748 749 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 750 if (log) { 751 SBStream sstr; 752 sb_error.GetDescription(sstr); 753 log->Printf("SBProcess(%p)::Kill () => SBError (%p): %s", 754 static_cast<void *>(process_sp.get()), 755 static_cast<void *>(sb_error.get()), sstr.GetData()); 756 } 757 758 return sb_error; 759 } 760 761 SBError SBProcess::Detach() { 762 // FIXME: This should come from a process default. 763 bool keep_stopped = false; 764 return Detach(keep_stopped); 765 } 766 767 SBError SBProcess::Detach(bool keep_stopped) { 768 SBError sb_error; 769 ProcessSP process_sp(GetSP()); 770 if (process_sp) { 771 std::lock_guard<std::recursive_mutex> guard( 772 process_sp->GetTarget().GetAPIMutex()); 773 sb_error.SetError(process_sp->Detach(keep_stopped)); 774 } else 775 sb_error.SetErrorString("SBProcess is invalid"); 776 777 return sb_error; 778 } 779 780 SBError SBProcess::Signal(int signo) { 781 SBError sb_error; 782 ProcessSP process_sp(GetSP()); 783 if (process_sp) { 784 std::lock_guard<std::recursive_mutex> guard( 785 process_sp->GetTarget().GetAPIMutex()); 786 sb_error.SetError(process_sp->Signal(signo)); 787 } else 788 sb_error.SetErrorString("SBProcess is invalid"); 789 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 790 if (log) { 791 SBStream sstr; 792 sb_error.GetDescription(sstr); 793 log->Printf("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s", 794 static_cast<void *>(process_sp.get()), signo, 795 static_cast<void *>(sb_error.get()), sstr.GetData()); 796 } 797 return sb_error; 798 } 799 800 SBUnixSignals SBProcess::GetUnixSignals() { 801 if (auto process_sp = GetSP()) 802 return SBUnixSignals{process_sp}; 803 804 return {}; 805 } 806 807 void SBProcess::SendAsyncInterrupt() { 808 ProcessSP process_sp(GetSP()); 809 if (process_sp) { 810 process_sp->SendAsyncInterrupt(); 811 } 812 } 813 814 SBThread SBProcess::GetThreadByID(tid_t tid) { 815 SBThread sb_thread; 816 ThreadSP thread_sp; 817 ProcessSP process_sp(GetSP()); 818 if (process_sp) { 819 Process::StopLocker stop_locker; 820 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 821 std::lock_guard<std::recursive_mutex> guard( 822 process_sp->GetTarget().GetAPIMutex()); 823 thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update); 824 sb_thread.SetThread(thread_sp); 825 } 826 827 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 828 if (log) 829 log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64 830 ") => SBThread (%p)", 831 static_cast<void *>(process_sp.get()), tid, 832 static_cast<void *>(thread_sp.get())); 833 834 return sb_thread; 835 } 836 837 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { 838 SBThread sb_thread; 839 ThreadSP thread_sp; 840 ProcessSP process_sp(GetSP()); 841 if (process_sp) { 842 Process::StopLocker stop_locker; 843 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 844 std::lock_guard<std::recursive_mutex> guard( 845 process_sp->GetTarget().GetAPIMutex()); 846 thread_sp = 847 process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update); 848 sb_thread.SetThread(thread_sp); 849 } 850 851 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 852 if (log) 853 log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)", 854 static_cast<void *>(process_sp.get()), index_id, 855 static_cast<void *>(thread_sp.get())); 856 857 return sb_thread; 858 } 859 860 StateType SBProcess::GetStateFromEvent(const SBEvent &event) { 861 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 862 863 StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); 864 865 if (log) 866 log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s", 867 static_cast<void *>(event.get()), 868 lldb_private::StateAsCString(ret_val)); 869 870 return ret_val; 871 } 872 873 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { 874 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 875 876 bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); 877 878 if (log) 879 log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__, 880 static_cast<void *>(event.get()), ret_val); 881 882 return ret_val; 883 } 884 885 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) { 886 return Process::ProcessEventData::GetNumRestartedReasons(event.get()); 887 } 888 889 const char * 890 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, 891 size_t idx) { 892 return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx); 893 } 894 895 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { 896 ProcessSP process_sp = 897 Process::ProcessEventData::GetProcessFromEvent(event.get()); 898 if (!process_sp) { 899 // StructuredData events also know the process they come from. Try that. 900 process_sp = EventDataStructuredData::GetProcessFromEvent(event.get()); 901 } 902 903 return SBProcess(process_sp); 904 } 905 906 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) { 907 return Process::ProcessEventData::GetInterruptedFromEvent(event.get()); 908 } 909 910 lldb::SBStructuredData 911 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) { 912 return SBStructuredData(event.GetSP()); 913 } 914 915 bool SBProcess::EventIsProcessEvent(const SBEvent &event) { 916 return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) && 917 !EventIsStructuredDataEvent(event); 918 } 919 920 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { 921 EventSP event_sp = event.GetSP(); 922 EventData *event_data = event_sp ? event_sp->GetData() : nullptr; 923 return event_data && (event_data->GetFlavor() == 924 EventDataStructuredData::GetFlavorString()); 925 } 926 927 SBBroadcaster SBProcess::GetBroadcaster() const { 928 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 929 930 ProcessSP process_sp(GetSP()); 931 932 SBBroadcaster broadcaster(process_sp.get(), false); 933 934 if (log) 935 log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", 936 static_cast<void *>(process_sp.get()), 937 static_cast<void *>(broadcaster.get())); 938 939 return broadcaster; 940 } 941 942 const char *SBProcess::GetBroadcasterClass() { 943 return Process::GetStaticBroadcasterClass().AsCString(); 944 } 945 946 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, 947 SBError &sb_error) { 948 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 949 950 size_t bytes_read = 0; 951 952 ProcessSP process_sp(GetSP()); 953 954 if (log) 955 log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 956 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...", 957 static_cast<void *>(process_sp.get()), addr, 958 static_cast<void *>(dst), static_cast<uint64_t>(dst_len), 959 static_cast<void *>(sb_error.get())); 960 961 if (process_sp) { 962 Process::StopLocker stop_locker; 963 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 964 std::lock_guard<std::recursive_mutex> guard( 965 process_sp->GetTarget().GetAPIMutex()); 966 bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref()); 967 } else { 968 if (log) 969 log->Printf("SBProcess(%p)::ReadMemory() => error: process is running", 970 static_cast<void *>(process_sp.get())); 971 sb_error.SetErrorString("process is running"); 972 } 973 } else { 974 sb_error.SetErrorString("SBProcess is invalid"); 975 } 976 977 if (log) { 978 SBStream sstr; 979 sb_error.GetDescription(sstr); 980 log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 981 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 982 static_cast<void *>(process_sp.get()), addr, 983 static_cast<void *>(dst), static_cast<uint64_t>(dst_len), 984 static_cast<void *>(sb_error.get()), sstr.GetData(), 985 static_cast<uint64_t>(bytes_read)); 986 } 987 988 return bytes_read; 989 } 990 991 size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, 992 lldb::SBError &sb_error) { 993 size_t bytes_read = 0; 994 ProcessSP process_sp(GetSP()); 995 if (process_sp) { 996 Process::StopLocker stop_locker; 997 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 998 std::lock_guard<std::recursive_mutex> guard( 999 process_sp->GetTarget().GetAPIMutex()); 1000 bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size, 1001 sb_error.ref()); 1002 } else { 1003 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1004 if (log) 1005 log->Printf("SBProcess(%p)::ReadCStringFromMemory() => error: process " 1006 "is running", 1007 static_cast<void *>(process_sp.get())); 1008 sb_error.SetErrorString("process is running"); 1009 } 1010 } else { 1011 sb_error.SetErrorString("SBProcess is invalid"); 1012 } 1013 return bytes_read; 1014 } 1015 1016 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, 1017 lldb::SBError &sb_error) { 1018 uint64_t value = 0; 1019 ProcessSP process_sp(GetSP()); 1020 if (process_sp) { 1021 Process::StopLocker stop_locker; 1022 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1023 std::lock_guard<std::recursive_mutex> guard( 1024 process_sp->GetTarget().GetAPIMutex()); 1025 value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0, 1026 sb_error.ref()); 1027 } else { 1028 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1029 if (log) 1030 log->Printf("SBProcess(%p)::ReadUnsignedFromMemory() => error: process " 1031 "is running", 1032 static_cast<void *>(process_sp.get())); 1033 sb_error.SetErrorString("process is running"); 1034 } 1035 } else { 1036 sb_error.SetErrorString("SBProcess is invalid"); 1037 } 1038 return value; 1039 } 1040 1041 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, 1042 lldb::SBError &sb_error) { 1043 lldb::addr_t ptr = LLDB_INVALID_ADDRESS; 1044 ProcessSP process_sp(GetSP()); 1045 if (process_sp) { 1046 Process::StopLocker stop_locker; 1047 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1048 std::lock_guard<std::recursive_mutex> guard( 1049 process_sp->GetTarget().GetAPIMutex()); 1050 ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref()); 1051 } else { 1052 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1053 if (log) 1054 log->Printf("SBProcess(%p)::ReadPointerFromMemory() => error: process " 1055 "is running", 1056 static_cast<void *>(process_sp.get())); 1057 sb_error.SetErrorString("process is running"); 1058 } 1059 } else { 1060 sb_error.SetErrorString("SBProcess is invalid"); 1061 } 1062 return ptr; 1063 } 1064 1065 size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, 1066 SBError &sb_error) { 1067 size_t bytes_written = 0; 1068 1069 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1070 1071 ProcessSP process_sp(GetSP()); 1072 1073 if (log) 1074 log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 1075 ", src=%p, src_len=%" PRIu64 ", SBError (%p))...", 1076 static_cast<void *>(process_sp.get()), addr, 1077 static_cast<const void *>(src), static_cast<uint64_t>(src_len), 1078 static_cast<void *>(sb_error.get())); 1079 1080 if (process_sp) { 1081 Process::StopLocker stop_locker; 1082 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1083 std::lock_guard<std::recursive_mutex> guard( 1084 process_sp->GetTarget().GetAPIMutex()); 1085 bytes_written = 1086 process_sp->WriteMemory(addr, src, src_len, sb_error.ref()); 1087 } else { 1088 if (log) 1089 log->Printf("SBProcess(%p)::WriteMemory() => error: process is running", 1090 static_cast<void *>(process_sp.get())); 1091 sb_error.SetErrorString("process is running"); 1092 } 1093 } 1094 1095 if (log) { 1096 SBStream sstr; 1097 sb_error.GetDescription(sstr); 1098 log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 1099 ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 1100 static_cast<void *>(process_sp.get()), addr, 1101 static_cast<const void *>(src), static_cast<uint64_t>(src_len), 1102 static_cast<void *>(sb_error.get()), sstr.GetData(), 1103 static_cast<uint64_t>(bytes_written)); 1104 } 1105 1106 return bytes_written; 1107 } 1108 1109 bool SBProcess::GetDescription(SBStream &description) { 1110 Stream &strm = description.ref(); 1111 1112 ProcessSP process_sp(GetSP()); 1113 if (process_sp) { 1114 char path[PATH_MAX]; 1115 GetTarget().GetExecutable().GetPath(path, sizeof(path)); 1116 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 1117 const char *exe_name = NULL; 1118 if (exe_module) 1119 exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); 1120 1121 strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", 1122 process_sp->GetID(), lldb_private::StateAsCString(GetState()), 1123 GetNumThreads(), exe_name ? ", executable = " : "", 1124 exe_name ? exe_name : ""); 1125 } else 1126 strm.PutCString("No value"); 1127 1128 return true; 1129 } 1130 1131 uint32_t 1132 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { 1133 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1134 1135 uint32_t num = 0; 1136 ProcessSP process_sp(GetSP()); 1137 if (process_sp) { 1138 std::lock_guard<std::recursive_mutex> guard( 1139 process_sp->GetTarget().GetAPIMutex()); 1140 sb_error.SetError(process_sp->GetWatchpointSupportInfo(num)); 1141 if (log) 1142 log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u", 1143 static_cast<void *>(process_sp.get()), num); 1144 } else { 1145 sb_error.SetErrorString("SBProcess is invalid"); 1146 } 1147 return num; 1148 } 1149 1150 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, 1151 lldb::SBError &sb_error) { 1152 return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error); 1153 } 1154 1155 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, 1156 const lldb::SBFileSpec &sb_remote_image_spec, 1157 lldb::SBError &sb_error) { 1158 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1159 ProcessSP process_sp(GetSP()); 1160 if (process_sp) { 1161 Process::StopLocker stop_locker; 1162 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1163 if (log) 1164 log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage" 1165 "for: %s", 1166 static_cast<void *>(process_sp.get()), 1167 sb_local_image_spec.GetFilename()); 1168 1169 std::lock_guard<std::recursive_mutex> guard( 1170 process_sp->GetTarget().GetAPIMutex()); 1171 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1172 return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, 1173 *sb_remote_image_spec, sb_error.ref()); 1174 } else { 1175 if (log) 1176 log->Printf("SBProcess(%p)::LoadImage() => error: process is running", 1177 static_cast<void *>(process_sp.get())); 1178 sb_error.SetErrorString("process is running"); 1179 } 1180 } else { 1181 if (log) 1182 log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid" 1183 " process", 1184 static_cast<void *>(process_sp.get())); 1185 sb_error.SetErrorString("process is invalid"); 1186 } 1187 return LLDB_INVALID_IMAGE_TOKEN; 1188 } 1189 1190 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, 1191 SBStringList &paths, 1192 lldb::SBFileSpec &loaded_path, 1193 lldb::SBError &error) { 1194 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1195 ProcessSP process_sp(GetSP()); 1196 if (process_sp) { 1197 Process::StopLocker stop_locker; 1198 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1199 if (log) 1200 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => " 1201 "calling Platform::LoadImageUsingPaths for: %s", 1202 static_cast<void *>(process_sp.get()), 1203 image_spec.GetFilename()); 1204 1205 std::lock_guard<std::recursive_mutex> guard( 1206 process_sp->GetTarget().GetAPIMutex()); 1207 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1208 size_t num_paths = paths.GetSize(); 1209 std::vector<std::string> paths_vec; 1210 paths_vec.reserve(num_paths); 1211 for (size_t i = 0; i < num_paths; i++) 1212 paths_vec.push_back(paths.GetStringAtIndex(i)); 1213 FileSpec loaded_spec; 1214 1215 uint32_t token = platform_sp->LoadImageUsingPaths(process_sp.get(), 1216 *image_spec, 1217 paths_vec, 1218 error.ref(), 1219 &loaded_spec); 1220 if (token != LLDB_INVALID_IMAGE_TOKEN) 1221 loaded_path = loaded_spec; 1222 return token; 1223 } else { 1224 if (log) 1225 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " 1226 "process is running", 1227 static_cast<void *>(process_sp.get())); 1228 error.SetErrorString("process is running"); 1229 } 1230 } else { 1231 if (log) 1232 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " 1233 "called with invalid process", 1234 static_cast<void *>(process_sp.get())); 1235 error.SetErrorString("process is invalid"); 1236 } 1237 1238 return LLDB_INVALID_IMAGE_TOKEN; 1239 } 1240 1241 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { 1242 lldb::SBError sb_error; 1243 ProcessSP process_sp(GetSP()); 1244 if (process_sp) { 1245 Process::StopLocker stop_locker; 1246 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1247 std::lock_guard<std::recursive_mutex> guard( 1248 process_sp->GetTarget().GetAPIMutex()); 1249 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1250 sb_error.SetError( 1251 platform_sp->UnloadImage(process_sp.get(), image_token)); 1252 } else { 1253 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1254 if (log) 1255 log->Printf("SBProcess(%p)::UnloadImage() => error: process is running", 1256 static_cast<void *>(process_sp.get())); 1257 sb_error.SetErrorString("process is running"); 1258 } 1259 } else 1260 sb_error.SetErrorString("invalid process"); 1261 return sb_error; 1262 } 1263 1264 lldb::SBError SBProcess::SendEventData(const char *event_data) { 1265 lldb::SBError sb_error; 1266 ProcessSP process_sp(GetSP()); 1267 if (process_sp) { 1268 Process::StopLocker stop_locker; 1269 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1270 std::lock_guard<std::recursive_mutex> guard( 1271 process_sp->GetTarget().GetAPIMutex()); 1272 sb_error.SetError(process_sp->SendEventData(event_data)); 1273 } else { 1274 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1275 if (log) 1276 log->Printf( 1277 "SBProcess(%p)::SendEventData() => error: process is running", 1278 static_cast<void *>(process_sp.get())); 1279 sb_error.SetErrorString("process is running"); 1280 } 1281 } else 1282 sb_error.SetErrorString("invalid process"); 1283 return sb_error; 1284 } 1285 1286 uint32_t SBProcess::GetNumExtendedBacktraceTypes() { 1287 ProcessSP process_sp(GetSP()); 1288 if (process_sp && process_sp->GetSystemRuntime()) { 1289 SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1290 return runtime->GetExtendedBacktraceTypes().size(); 1291 } 1292 return 0; 1293 } 1294 1295 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { 1296 ProcessSP process_sp(GetSP()); 1297 if (process_sp && process_sp->GetSystemRuntime()) { 1298 SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1299 const std::vector<ConstString> &names = 1300 runtime->GetExtendedBacktraceTypes(); 1301 if (idx < names.size()) { 1302 return names[idx].AsCString(); 1303 } else { 1304 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1305 if (log) 1306 log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => " 1307 "error: requested extended backtrace name out of bounds", 1308 static_cast<void *>(process_sp.get())); 1309 } 1310 } 1311 return NULL; 1312 } 1313 1314 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { 1315 ProcessSP process_sp(GetSP()); 1316 SBThreadCollection threads; 1317 if (process_sp) { 1318 threads = SBThreadCollection(process_sp->GetHistoryThreads(addr)); 1319 } 1320 return threads; 1321 } 1322 1323 bool SBProcess::IsInstrumentationRuntimePresent( 1324 InstrumentationRuntimeType type) { 1325 ProcessSP process_sp(GetSP()); 1326 if (!process_sp) 1327 return false; 1328 1329 InstrumentationRuntimeSP runtime_sp = 1330 process_sp->GetInstrumentationRuntime(type); 1331 1332 if (!runtime_sp.get()) 1333 return false; 1334 1335 return runtime_sp->IsActive(); 1336 } 1337 1338 lldb::SBError SBProcess::SaveCore(const char *file_name) { 1339 lldb::SBError error; 1340 ProcessSP process_sp(GetSP()); 1341 if (!process_sp) { 1342 error.SetErrorString("SBProcess is invalid"); 1343 return error; 1344 } 1345 1346 std::lock_guard<std::recursive_mutex> guard( 1347 process_sp->GetTarget().GetAPIMutex()); 1348 1349 if (process_sp->GetState() != eStateStopped) { 1350 error.SetErrorString("the process is not stopped"); 1351 return error; 1352 } 1353 1354 FileSpec core_file(file_name, false); 1355 error.ref() = PluginManager::SaveCore(process_sp, core_file); 1356 return error; 1357 } 1358 1359 lldb::SBError 1360 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, 1361 SBMemoryRegionInfo &sb_region_info) { 1362 lldb::SBError sb_error; 1363 ProcessSP process_sp(GetSP()); 1364 MemoryRegionInfoSP region_info_sp = 1365 std::make_shared<lldb_private::MemoryRegionInfo>(); 1366 if (process_sp) { 1367 Process::StopLocker stop_locker; 1368 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1369 std::lock_guard<std::recursive_mutex> guard( 1370 process_sp->GetTarget().GetAPIMutex()); 1371 sb_error.ref() = 1372 process_sp->GetMemoryRegionInfo(load_addr, *region_info_sp); 1373 if (sb_error.Success()) { 1374 sb_region_info.ref() = *region_info_sp; 1375 } 1376 } else { 1377 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1378 if (log) 1379 log->Printf( 1380 "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", 1381 static_cast<void *>(process_sp.get())); 1382 sb_error.SetErrorString("process is running"); 1383 } 1384 } else { 1385 sb_error.SetErrorString("SBProcess is invalid"); 1386 } 1387 return sb_error; 1388 } 1389 1390 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { 1391 lldb::SBError sb_error; 1392 lldb::SBMemoryRegionInfoList sb_region_list; 1393 ProcessSP process_sp(GetSP()); 1394 if (process_sp) { 1395 Process::StopLocker stop_locker; 1396 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1397 std::lock_guard<std::recursive_mutex> guard( 1398 process_sp->GetTarget().GetAPIMutex()); 1399 std::vector<MemoryRegionInfoSP> region_list; 1400 sb_error.ref() = process_sp->GetMemoryRegions(region_list); 1401 if (sb_error.Success()) { 1402 std::vector<MemoryRegionInfoSP>::iterator end = region_list.end(); 1403 for (std::vector<MemoryRegionInfoSP>::iterator it = region_list.begin(); 1404 it != end; it++) { 1405 SBMemoryRegionInfo sb_region_info(it->get()); 1406 sb_region_list.Append(sb_region_info); 1407 } 1408 } 1409 } else { 1410 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1411 if (log) 1412 log->Printf( 1413 "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", 1414 static_cast<void *>(process_sp.get())); 1415 sb_error.SetErrorString("process is running"); 1416 } 1417 } else { 1418 sb_error.SetErrorString("SBProcess is invalid"); 1419 } 1420 return sb_region_list; 1421 } 1422 1423 lldb::SBProcessInfo SBProcess::GetProcessInfo() { 1424 lldb::SBProcessInfo sb_proc_info; 1425 ProcessSP process_sp(GetSP()); 1426 ProcessInstanceInfo proc_info; 1427 if (process_sp && process_sp->GetProcessInfo(proc_info)) { 1428 sb_proc_info.SetProcessInfo(proc_info); 1429 } 1430 return sb_proc_info; 1431 } 1432