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