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