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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 LogSP 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 SBProcess 913 SBProcess::GetProcessFromEvent (const SBEvent &event) 914 { 915 SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.get())); 916 return process; 917 } 918 919 bool 920 SBProcess::EventIsProcessEvent (const SBEvent &event) 921 { 922 return strcmp (event.GetBroadcasterClass(), SBProcess::GetBroadcasterClass()) == 0; 923 } 924 925 SBBroadcaster 926 SBProcess::GetBroadcaster () const 927 { 928 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 929 930 ProcessSP process_sp(GetSP()); 931 932 SBBroadcaster broadcaster(process_sp.get(), false); 933 934 if (log) 935 log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", process_sp.get(), 936 broadcaster.get()); 937 938 return broadcaster; 939 } 940 941 const char * 942 SBProcess::GetBroadcasterClass () 943 { 944 return Process::GetStaticBroadcasterClass().AsCString(); 945 } 946 947 size_t 948 SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error) 949 { 950 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 951 952 size_t bytes_read = 0; 953 954 ProcessSP process_sp(GetSP()); 955 956 if (log) 957 { 958 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...", 959 process_sp.get(), 960 addr, 961 dst, 962 (uint64_t)dst_len, 963 sb_error.get()); 964 } 965 966 if (process_sp) 967 { 968 Process::StopLocker stop_locker; 969 if (stop_locker.TryLock(&process_sp->GetRunLock())) 970 { 971 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 972 bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref()); 973 } 974 else 975 { 976 if (log) 977 log->Printf ("SBProcess(%p)::ReadMemory() => error: process is running", process_sp.get()); 978 sb_error.SetErrorString("process is running"); 979 } 980 } 981 else 982 { 983 sb_error.SetErrorString ("SBProcess is invalid"); 984 } 985 986 if (log) 987 { 988 SBStream sstr; 989 sb_error.GetDescription (sstr); 990 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 991 process_sp.get(), 992 addr, 993 dst, 994 (uint64_t)dst_len, 995 sb_error.get(), 996 sstr.GetData(), 997 (uint64_t)bytes_read); 998 } 999 1000 return bytes_read; 1001 } 1002 1003 size_t 1004 SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &sb_error) 1005 { 1006 size_t bytes_read = 0; 1007 ProcessSP process_sp(GetSP()); 1008 if (process_sp) 1009 { 1010 Process::StopLocker stop_locker; 1011 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1012 { 1013 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1014 bytes_read = process_sp->ReadCStringFromMemory (addr, (char *)buf, size, sb_error.ref()); 1015 } 1016 else 1017 { 1018 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1019 if (log) 1020 log->Printf ("SBProcess(%p)::ReadCStringFromMemory() => error: process is running", process_sp.get()); 1021 sb_error.SetErrorString("process is running"); 1022 } 1023 } 1024 else 1025 { 1026 sb_error.SetErrorString ("SBProcess is invalid"); 1027 } 1028 return bytes_read; 1029 } 1030 1031 uint64_t 1032 SBProcess::ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &sb_error) 1033 { 1034 uint64_t value = 0; 1035 ProcessSP process_sp(GetSP()); 1036 if (process_sp) 1037 { 1038 Process::StopLocker stop_locker; 1039 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1040 { 1041 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1042 value = process_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, sb_error.ref()); 1043 } 1044 else 1045 { 1046 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1047 if (log) 1048 log->Printf ("SBProcess(%p)::ReadUnsignedFromMemory() => error: process is running", process_sp.get()); 1049 sb_error.SetErrorString("process is running"); 1050 } 1051 } 1052 else 1053 { 1054 sb_error.SetErrorString ("SBProcess is invalid"); 1055 } 1056 return value; 1057 } 1058 1059 lldb::addr_t 1060 SBProcess::ReadPointerFromMemory (addr_t addr, lldb::SBError &sb_error) 1061 { 1062 lldb::addr_t ptr = LLDB_INVALID_ADDRESS; 1063 ProcessSP process_sp(GetSP()); 1064 if (process_sp) 1065 { 1066 Process::StopLocker stop_locker; 1067 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1068 { 1069 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1070 ptr = process_sp->ReadPointerFromMemory (addr, sb_error.ref()); 1071 } 1072 else 1073 { 1074 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1075 if (log) 1076 log->Printf ("SBProcess(%p)::ReadPointerFromMemory() => error: process is running", process_sp.get()); 1077 sb_error.SetErrorString("process is running"); 1078 } 1079 } 1080 else 1081 { 1082 sb_error.SetErrorString ("SBProcess is invalid"); 1083 } 1084 return ptr; 1085 } 1086 1087 size_t 1088 SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error) 1089 { 1090 size_t bytes_written = 0; 1091 1092 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1093 1094 ProcessSP process_sp(GetSP()); 1095 1096 if (log) 1097 { 1098 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p))...", 1099 process_sp.get(), 1100 addr, 1101 src, 1102 (uint64_t)src_len, 1103 sb_error.get()); 1104 } 1105 1106 if (process_sp) 1107 { 1108 Process::StopLocker stop_locker; 1109 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1110 { 1111 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1112 bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref()); 1113 } 1114 else 1115 { 1116 if (log) 1117 log->Printf ("SBProcess(%p)::WriteMemory() => error: process is running", process_sp.get()); 1118 sb_error.SetErrorString("process is running"); 1119 } 1120 } 1121 1122 if (log) 1123 { 1124 SBStream sstr; 1125 sb_error.GetDescription (sstr); 1126 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 1127 process_sp.get(), 1128 addr, 1129 src, 1130 (uint64_t)src_len, 1131 sb_error.get(), 1132 sstr.GetData(), 1133 (uint64_t)bytes_written); 1134 } 1135 1136 return bytes_written; 1137 } 1138 1139 bool 1140 SBProcess::GetDescription (SBStream &description) 1141 { 1142 Stream &strm = description.ref(); 1143 1144 ProcessSP process_sp(GetSP()); 1145 if (process_sp) 1146 { 1147 char path[PATH_MAX]; 1148 GetTarget().GetExecutable().GetPath (path, sizeof(path)); 1149 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 1150 const char *exe_name = NULL; 1151 if (exe_module) 1152 exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); 1153 1154 strm.Printf ("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", 1155 process_sp->GetID(), 1156 lldb_private::StateAsCString (GetState()), 1157 GetNumThreads(), 1158 exe_name ? ", executable = " : "", 1159 exe_name ? exe_name : ""); 1160 } 1161 else 1162 strm.PutCString ("No value"); 1163 1164 return true; 1165 } 1166 1167 uint32_t 1168 SBProcess::GetNumSupportedHardwareWatchpoints (lldb::SBError &sb_error) const 1169 { 1170 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1171 1172 uint32_t num = 0; 1173 ProcessSP process_sp(GetSP()); 1174 if (process_sp) 1175 { 1176 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1177 sb_error.SetError(process_sp->GetWatchpointSupportInfo (num)); 1178 if (log) 1179 log->Printf ("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u", 1180 process_sp.get(), num); 1181 } 1182 else 1183 { 1184 sb_error.SetErrorString ("SBProcess is invalid"); 1185 } 1186 return num; 1187 } 1188 1189 uint32_t 1190 SBProcess::LoadImage (lldb::SBFileSpec &sb_image_spec, lldb::SBError &sb_error) 1191 { 1192 ProcessSP process_sp(GetSP()); 1193 if (process_sp) 1194 { 1195 Process::StopLocker stop_locker; 1196 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1197 { 1198 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1199 return process_sp->LoadImage (*sb_image_spec, sb_error.ref()); 1200 } 1201 else 1202 { 1203 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1204 if (log) 1205 log->Printf ("SBProcess(%p)::LoadImage() => error: process is running", process_sp.get()); 1206 sb_error.SetErrorString("process is running"); 1207 } 1208 } 1209 return LLDB_INVALID_IMAGE_TOKEN; 1210 } 1211 1212 lldb::SBError 1213 SBProcess::UnloadImage (uint32_t image_token) 1214 { 1215 lldb::SBError sb_error; 1216 ProcessSP process_sp(GetSP()); 1217 if (process_sp) 1218 { 1219 Process::StopLocker stop_locker; 1220 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1221 { 1222 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1223 sb_error.SetError (process_sp->UnloadImage (image_token)); 1224 } 1225 else 1226 { 1227 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1228 if (log) 1229 log->Printf ("SBProcess(%p)::UnloadImage() => error: process is running", process_sp.get()); 1230 sb_error.SetErrorString("process is running"); 1231 } 1232 } 1233 else 1234 sb_error.SetErrorString("invalid process"); 1235 return sb_error; 1236 } 1237