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