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 SBTarget 282 SBProcess::GetTarget() const 283 { 284 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 285 286 SBTarget sb_target; 287 TargetSP target_sp; 288 ProcessSP process_sp(GetSP()); 289 if (process_sp) 290 { 291 target_sp = process_sp->GetTarget().shared_from_this(); 292 sb_target.SetSP (target_sp); 293 } 294 295 if (log) 296 log->Printf ("SBProcess(%p)::GetTarget () => SBTarget(%p)", process_sp.get(), target_sp.get()); 297 298 return sb_target; 299 } 300 301 302 size_t 303 SBProcess::PutSTDIN (const char *src, size_t src_len) 304 { 305 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 306 307 size_t ret_val = 0; 308 ProcessSP process_sp(GetSP()); 309 if (process_sp) 310 { 311 Error error; 312 ret_val = process_sp->PutSTDIN (src, src_len, error); 313 } 314 315 if (log) 316 log->Printf ("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%d) => %lu", 317 process_sp.get(), 318 src, 319 (uint32_t) src_len, 320 ret_val); 321 322 return ret_val; 323 } 324 325 size_t 326 SBProcess::GetSTDOUT (char *dst, size_t dst_len) const 327 { 328 size_t bytes_read = 0; 329 ProcessSP process_sp(GetSP()); 330 if (process_sp) 331 { 332 Error error; 333 bytes_read = process_sp->GetSTDOUT (dst, dst_len, error); 334 } 335 336 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 337 if (log) 338 log->Printf ("SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64, 339 process_sp.get(), 340 (int) bytes_read, 341 dst, 342 (uint64_t)dst_len, 343 (uint64_t)bytes_read); 344 345 return bytes_read; 346 } 347 348 size_t 349 SBProcess::GetSTDERR (char *dst, size_t dst_len) const 350 { 351 size_t bytes_read = 0; 352 ProcessSP process_sp(GetSP()); 353 if (process_sp) 354 { 355 Error error; 356 bytes_read = process_sp->GetSTDERR (dst, dst_len, error); 357 } 358 359 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 360 if (log) 361 log->Printf ("SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64, 362 process_sp.get(), 363 (int) bytes_read, 364 dst, 365 (uint64_t)dst_len, 366 (uint64_t)bytes_read); 367 368 return bytes_read; 369 } 370 371 size_t 372 SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const 373 { 374 size_t bytes_read = 0; 375 ProcessSP process_sp(GetSP()); 376 if (process_sp) 377 { 378 Error error; 379 bytes_read = process_sp->GetAsyncProfileData (dst, dst_len, error); 380 } 381 382 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 383 if (log) 384 log->Printf ("SBProcess(%p)::GetProfileData (dst=\"%.*s\", dst_len=%" PRIu64 ") => %" PRIu64, 385 process_sp.get(), 386 (int) bytes_read, 387 dst, 388 (uint64_t)dst_len, 389 (uint64_t)bytes_read); 390 391 return bytes_read; 392 } 393 394 void 395 SBProcess::ReportEventState (const SBEvent &event, FILE *out) const 396 { 397 if (out == NULL) 398 return; 399 400 ProcessSP process_sp(GetSP()); 401 if (process_sp) 402 { 403 const StateType event_state = SBProcess::GetStateFromEvent (event); 404 char message[1024]; 405 int message_len = ::snprintf (message, 406 sizeof (message), 407 "Process %" PRIu64 " %s\n", 408 process_sp->GetID(), 409 SBDebugger::StateAsCString (event_state)); 410 411 if (message_len > 0) 412 ::fwrite (message, 1, message_len, out); 413 } 414 } 415 416 void 417 SBProcess::AppendEventStateReport (const SBEvent &event, SBCommandReturnObject &result) 418 { 419 ProcessSP process_sp(GetSP()); 420 if (process_sp) 421 { 422 const StateType event_state = SBProcess::GetStateFromEvent (event); 423 char message[1024]; 424 ::snprintf (message, 425 sizeof (message), 426 "Process %" PRIu64 " %s\n", 427 process_sp->GetID(), 428 SBDebugger::StateAsCString (event_state)); 429 430 result.AppendMessage (message); 431 } 432 } 433 434 bool 435 SBProcess::SetSelectedThread (const SBThread &thread) 436 { 437 ProcessSP process_sp(GetSP()); 438 if (process_sp) 439 { 440 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 441 return process_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID()); 442 } 443 return false; 444 } 445 446 bool 447 SBProcess::SetSelectedThreadByID (lldb::tid_t tid) 448 { 449 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 450 451 bool ret_val = false; 452 ProcessSP process_sp(GetSP()); 453 if (process_sp) 454 { 455 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 456 ret_val = process_sp->GetThreadList().SetSelectedThreadByID (tid); 457 } 458 459 if (log) 460 log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64 ") => %s", 461 process_sp.get(), tid, (ret_val ? "true" : "false")); 462 463 return ret_val; 464 } 465 466 bool 467 SBProcess::SetSelectedThreadByIndexID (uint32_t index_id) 468 { 469 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 470 471 bool ret_val = false; 472 ProcessSP process_sp(GetSP()); 473 if (process_sp) 474 { 475 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 476 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID (index_id); 477 } 478 479 if (log) 480 log->Printf ("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s", 481 process_sp.get(), index_id, (ret_val ? "true" : "false")); 482 483 return ret_val; 484 } 485 486 SBThread 487 SBProcess::GetThreadAtIndex (size_t index) 488 { 489 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 490 491 SBThread sb_thread; 492 ThreadSP thread_sp; 493 ProcessSP process_sp(GetSP()); 494 if (process_sp) 495 { 496 Process::StopLocker stop_locker; 497 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 498 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 499 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update); 500 sb_thread.SetThread (thread_sp); 501 } 502 503 if (log) 504 { 505 log->Printf ("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)", 506 process_sp.get(), (uint32_t) index, thread_sp.get()); 507 } 508 509 return sb_thread; 510 } 511 512 uint32_t 513 SBProcess::GetStopID(bool include_expression_stops) 514 { 515 ProcessSP process_sp(GetSP()); 516 if (process_sp) 517 { 518 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 519 if (include_expression_stops) 520 return process_sp->GetStopID(); 521 else 522 return process_sp->GetLastNaturalStopID(); 523 } 524 return 0; 525 } 526 527 StateType 528 SBProcess::GetState () 529 { 530 531 StateType ret_val = eStateInvalid; 532 ProcessSP process_sp(GetSP()); 533 if (process_sp) 534 { 535 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 536 ret_val = process_sp->GetState(); 537 } 538 539 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 540 if (log) 541 log->Printf ("SBProcess(%p)::GetState () => %s", 542 process_sp.get(), 543 lldb_private::StateAsCString (ret_val)); 544 545 return ret_val; 546 } 547 548 549 int 550 SBProcess::GetExitStatus () 551 { 552 int exit_status = 0; 553 ProcessSP process_sp(GetSP()); 554 if (process_sp) 555 { 556 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 557 exit_status = process_sp->GetExitStatus (); 558 } 559 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 560 if (log) 561 log->Printf ("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)", 562 process_sp.get(), exit_status, exit_status); 563 564 return exit_status; 565 } 566 567 const char * 568 SBProcess::GetExitDescription () 569 { 570 const char *exit_desc = NULL; 571 ProcessSP process_sp(GetSP()); 572 if (process_sp) 573 { 574 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 575 exit_desc = process_sp->GetExitDescription (); 576 } 577 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 578 if (log) 579 log->Printf ("SBProcess(%p)::GetExitDescription () => %s", 580 process_sp.get(), exit_desc); 581 return exit_desc; 582 } 583 584 lldb::pid_t 585 SBProcess::GetProcessID () 586 { 587 lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; 588 ProcessSP process_sp(GetSP()); 589 if (process_sp) 590 ret_val = process_sp->GetID(); 591 592 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 593 if (log) 594 log->Printf ("SBProcess(%p)::GetProcessID () => %" PRIu64, process_sp.get(), ret_val); 595 596 return ret_val; 597 } 598 599 uint32_t 600 SBProcess::GetUniqueID() 601 { 602 uint32_t ret_val = 0; 603 ProcessSP process_sp(GetSP()); 604 if (process_sp) 605 ret_val = process_sp->GetUniqueID(); 606 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 607 if (log) 608 log->Printf ("SBProcess(%p)::GetUniqueID () => %" PRIu32, process_sp.get(), ret_val); 609 return ret_val; 610 } 611 612 ByteOrder 613 SBProcess::GetByteOrder () const 614 { 615 ByteOrder byteOrder = eByteOrderInvalid; 616 ProcessSP process_sp(GetSP()); 617 if (process_sp) 618 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); 619 620 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 621 if (log) 622 log->Printf ("SBProcess(%p)::GetByteOrder () => %d", process_sp.get(), byteOrder); 623 624 return byteOrder; 625 } 626 627 uint32_t 628 SBProcess::GetAddressByteSize () const 629 { 630 uint32_t size = 0; 631 ProcessSP process_sp(GetSP()); 632 if (process_sp) 633 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); 634 635 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 636 if (log) 637 log->Printf ("SBProcess(%p)::GetAddressByteSize () => %d", process_sp.get(), size); 638 639 return size; 640 } 641 642 SBError 643 SBProcess::Continue () 644 { 645 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 646 647 SBError sb_error; 648 ProcessSP process_sp(GetSP()); 649 650 if (log) 651 log->Printf ("SBProcess(%p)::Continue ()...", process_sp.get()); 652 653 if (process_sp) 654 { 655 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 656 657 Error error (process_sp->Resume()); 658 if (error.Success()) 659 { 660 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution () == false) 661 { 662 if (log) 663 log->Printf ("SBProcess(%p)::Continue () waiting for process to stop...", process_sp.get()); 664 process_sp->WaitForProcessToStop (NULL); 665 } 666 } 667 sb_error.SetError(error); 668 } 669 else 670 sb_error.SetErrorString ("SBProcess is invalid"); 671 672 if (log) 673 { 674 SBStream sstr; 675 sb_error.GetDescription (sstr); 676 log->Printf ("SBProcess(%p)::Continue () => SBError (%p): %s", process_sp.get(), sb_error.get(), sstr.GetData()); 677 } 678 679 return sb_error; 680 } 681 682 683 SBError 684 SBProcess::Destroy () 685 { 686 SBError sb_error; 687 ProcessSP process_sp(GetSP()); 688 if (process_sp) 689 { 690 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 691 sb_error.SetError(process_sp->Destroy()); 692 } 693 else 694 sb_error.SetErrorString ("SBProcess is invalid"); 695 696 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 697 if (log) 698 { 699 SBStream sstr; 700 sb_error.GetDescription (sstr); 701 log->Printf ("SBProcess(%p)::Destroy () => SBError (%p): %s", 702 process_sp.get(), 703 sb_error.get(), 704 sstr.GetData()); 705 } 706 707 return sb_error; 708 } 709 710 711 SBError 712 SBProcess::Stop () 713 { 714 SBError sb_error; 715 ProcessSP process_sp(GetSP()); 716 if (process_sp) 717 { 718 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 719 sb_error.SetError (process_sp->Halt()); 720 } 721 else 722 sb_error.SetErrorString ("SBProcess is invalid"); 723 724 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 725 if (log) 726 { 727 SBStream sstr; 728 sb_error.GetDescription (sstr); 729 log->Printf ("SBProcess(%p)::Stop () => SBError (%p): %s", 730 process_sp.get(), 731 sb_error.get(), 732 sstr.GetData()); 733 } 734 735 return sb_error; 736 } 737 738 SBError 739 SBProcess::Kill () 740 { 741 SBError sb_error; 742 ProcessSP process_sp(GetSP()); 743 if (process_sp) 744 { 745 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 746 sb_error.SetError (process_sp->Destroy()); 747 } 748 else 749 sb_error.SetErrorString ("SBProcess is invalid"); 750 751 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 752 if (log) 753 { 754 SBStream sstr; 755 sb_error.GetDescription (sstr); 756 log->Printf ("SBProcess(%p)::Kill () => SBError (%p): %s", 757 process_sp.get(), 758 sb_error.get(), 759 sstr.GetData()); 760 } 761 762 return sb_error; 763 } 764 765 SBError 766 SBProcess::Detach () 767 { 768 SBError sb_error; 769 ProcessSP process_sp(GetSP()); 770 if (process_sp) 771 { 772 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 773 sb_error.SetError (process_sp->Detach()); 774 } 775 else 776 sb_error.SetErrorString ("SBProcess is invalid"); 777 778 return sb_error; 779 } 780 781 SBError 782 SBProcess::Signal (int signo) 783 { 784 SBError sb_error; 785 ProcessSP process_sp(GetSP()); 786 if (process_sp) 787 { 788 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 789 sb_error.SetError (process_sp->Signal (signo)); 790 } 791 else 792 sb_error.SetErrorString ("SBProcess is invalid"); 793 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 794 if (log) 795 { 796 SBStream sstr; 797 sb_error.GetDescription (sstr); 798 log->Printf ("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s", 799 process_sp.get(), 800 signo, 801 sb_error.get(), 802 sstr.GetData()); 803 } 804 return sb_error; 805 } 806 807 void 808 SBProcess::SendAsyncInterrupt () 809 { 810 ProcessSP process_sp(GetSP()); 811 if (process_sp) 812 { 813 process_sp->SendAsyncInterrupt (); 814 } 815 } 816 817 SBThread 818 SBProcess::GetThreadByID (tid_t tid) 819 { 820 SBThread sb_thread; 821 ThreadSP thread_sp; 822 ProcessSP process_sp(GetSP()); 823 if (process_sp) 824 { 825 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 826 Process::StopLocker stop_locker; 827 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 828 thread_sp = process_sp->GetThreadList().FindThreadByID (tid, can_update); 829 sb_thread.SetThread (thread_sp); 830 } 831 832 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 833 if (log) 834 { 835 log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64 ") => SBThread (%p)", 836 process_sp.get(), 837 tid, 838 thread_sp.get()); 839 } 840 841 return sb_thread; 842 } 843 844 SBThread 845 SBProcess::GetThreadByIndexID (uint32_t index_id) 846 { 847 SBThread sb_thread; 848 ThreadSP thread_sp; 849 ProcessSP process_sp(GetSP()); 850 if (process_sp) 851 { 852 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 853 Process::StopLocker stop_locker; 854 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 855 thread_sp = process_sp->GetThreadList().FindThreadByIndexID (index_id, can_update); 856 sb_thread.SetThread (thread_sp); 857 } 858 859 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 860 if (log) 861 { 862 log->Printf ("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)", 863 process_sp.get(), 864 index_id, 865 thread_sp.get()); 866 } 867 868 return sb_thread; 869 } 870 871 StateType 872 SBProcess::GetStateFromEvent (const SBEvent &event) 873 { 874 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 875 876 StateType ret_val = Process::ProcessEventData::GetStateFromEvent (event.get()); 877 878 if (log) 879 log->Printf ("SBProcess::GetStateFromEvent (event.sp=%p) => %s", event.get(), 880 lldb_private::StateAsCString (ret_val)); 881 882 return ret_val; 883 } 884 885 bool 886 SBProcess::GetRestartedFromEvent (const SBEvent &event) 887 { 888 return Process::ProcessEventData::GetRestartedFromEvent (event.get()); 889 } 890 891 SBProcess 892 SBProcess::GetProcessFromEvent (const SBEvent &event) 893 { 894 SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.get())); 895 return process; 896 } 897 898 bool 899 SBProcess::EventIsProcessEvent (const SBEvent &event) 900 { 901 return strcmp (event.GetBroadcasterClass(), SBProcess::GetBroadcasterClass()) == 0; 902 } 903 904 SBBroadcaster 905 SBProcess::GetBroadcaster () const 906 { 907 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 908 909 ProcessSP process_sp(GetSP()); 910 911 SBBroadcaster broadcaster(process_sp.get(), false); 912 913 if (log) 914 log->Printf ("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", process_sp.get(), 915 broadcaster.get()); 916 917 return broadcaster; 918 } 919 920 const char * 921 SBProcess::GetBroadcasterClass () 922 { 923 return Process::GetStaticBroadcasterClass().AsCString(); 924 } 925 926 size_t 927 SBProcess::ReadMemory (addr_t addr, void *dst, size_t dst_len, SBError &sb_error) 928 { 929 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 930 931 size_t bytes_read = 0; 932 933 ProcessSP process_sp(GetSP()); 934 935 if (log) 936 { 937 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...", 938 process_sp.get(), 939 addr, 940 dst, 941 (uint64_t)dst_len, 942 sb_error.get()); 943 } 944 945 if (process_sp) 946 { 947 Process::StopLocker stop_locker; 948 if (stop_locker.TryLock(&process_sp->GetRunLock())) 949 { 950 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 951 bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref()); 952 } 953 else 954 { 955 if (log) 956 log->Printf ("SBProcess(%p)::ReadMemory() => error: process is running", process_sp.get()); 957 sb_error.SetErrorString("process is running"); 958 } 959 } 960 else 961 { 962 sb_error.SetErrorString ("SBProcess is invalid"); 963 } 964 965 if (log) 966 { 967 SBStream sstr; 968 sb_error.GetDescription (sstr); 969 log->Printf ("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 970 process_sp.get(), 971 addr, 972 dst, 973 (uint64_t)dst_len, 974 sb_error.get(), 975 sstr.GetData(), 976 (uint64_t)bytes_read); 977 } 978 979 return bytes_read; 980 } 981 982 size_t 983 SBProcess::ReadCStringFromMemory (addr_t addr, void *buf, size_t size, lldb::SBError &sb_error) 984 { 985 size_t bytes_read = 0; 986 ProcessSP process_sp(GetSP()); 987 if (process_sp) 988 { 989 Process::StopLocker stop_locker; 990 if (stop_locker.TryLock(&process_sp->GetRunLock())) 991 { 992 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 993 bytes_read = process_sp->ReadCStringFromMemory (addr, (char *)buf, size, sb_error.ref()); 994 } 995 else 996 { 997 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 998 if (log) 999 log->Printf ("SBProcess(%p)::ReadCStringFromMemory() => error: process is running", process_sp.get()); 1000 sb_error.SetErrorString("process is running"); 1001 } 1002 } 1003 else 1004 { 1005 sb_error.SetErrorString ("SBProcess is invalid"); 1006 } 1007 return bytes_read; 1008 } 1009 1010 uint64_t 1011 SBProcess::ReadUnsignedFromMemory (addr_t addr, uint32_t byte_size, lldb::SBError &sb_error) 1012 { 1013 uint64_t value = 0; 1014 ProcessSP process_sp(GetSP()); 1015 if (process_sp) 1016 { 1017 Process::StopLocker stop_locker; 1018 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1019 { 1020 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1021 value = process_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, sb_error.ref()); 1022 } 1023 else 1024 { 1025 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1026 if (log) 1027 log->Printf ("SBProcess(%p)::ReadUnsignedFromMemory() => error: process is running", process_sp.get()); 1028 sb_error.SetErrorString("process is running"); 1029 } 1030 } 1031 else 1032 { 1033 sb_error.SetErrorString ("SBProcess is invalid"); 1034 } 1035 return value; 1036 } 1037 1038 lldb::addr_t 1039 SBProcess::ReadPointerFromMemory (addr_t addr, lldb::SBError &sb_error) 1040 { 1041 lldb::addr_t ptr = LLDB_INVALID_ADDRESS; 1042 ProcessSP process_sp(GetSP()); 1043 if (process_sp) 1044 { 1045 Process::StopLocker stop_locker; 1046 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1047 { 1048 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1049 ptr = process_sp->ReadPointerFromMemory (addr, sb_error.ref()); 1050 } 1051 else 1052 { 1053 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1054 if (log) 1055 log->Printf ("SBProcess(%p)::ReadPointerFromMemory() => error: process is running", process_sp.get()); 1056 sb_error.SetErrorString("process is running"); 1057 } 1058 } 1059 else 1060 { 1061 sb_error.SetErrorString ("SBProcess is invalid"); 1062 } 1063 return ptr; 1064 } 1065 1066 size_t 1067 SBProcess::WriteMemory (addr_t addr, const void *src, size_t src_len, SBError &sb_error) 1068 { 1069 size_t bytes_written = 0; 1070 1071 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1072 1073 ProcessSP process_sp(GetSP()); 1074 1075 if (log) 1076 { 1077 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p))...", 1078 process_sp.get(), 1079 addr, 1080 src, 1081 (uint64_t)src_len, 1082 sb_error.get()); 1083 } 1084 1085 if (process_sp) 1086 { 1087 Process::StopLocker stop_locker; 1088 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1089 { 1090 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1091 bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref()); 1092 } 1093 else 1094 { 1095 if (log) 1096 log->Printf ("SBProcess(%p)::WriteMemory() => error: process is running", process_sp.get()); 1097 sb_error.SetErrorString("process is running"); 1098 } 1099 } 1100 1101 if (log) 1102 { 1103 SBStream sstr; 1104 sb_error.GetDescription (sstr); 1105 log->Printf ("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 1106 process_sp.get(), 1107 addr, 1108 src, 1109 (uint64_t)src_len, 1110 sb_error.get(), 1111 sstr.GetData(), 1112 (uint64_t)bytes_written); 1113 } 1114 1115 return bytes_written; 1116 } 1117 1118 bool 1119 SBProcess::GetDescription (SBStream &description) 1120 { 1121 Stream &strm = description.ref(); 1122 1123 ProcessSP process_sp(GetSP()); 1124 if (process_sp) 1125 { 1126 char path[PATH_MAX]; 1127 GetTarget().GetExecutable().GetPath (path, sizeof(path)); 1128 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 1129 const char *exe_name = NULL; 1130 if (exe_module) 1131 exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); 1132 1133 strm.Printf ("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", 1134 process_sp->GetID(), 1135 lldb_private::StateAsCString (GetState()), 1136 GetNumThreads(), 1137 exe_name ? ", executable = " : "", 1138 exe_name ? exe_name : ""); 1139 } 1140 else 1141 strm.PutCString ("No value"); 1142 1143 return true; 1144 } 1145 1146 uint32_t 1147 SBProcess::GetNumSupportedHardwareWatchpoints (lldb::SBError &sb_error) const 1148 { 1149 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1150 1151 uint32_t num = 0; 1152 ProcessSP process_sp(GetSP()); 1153 if (process_sp) 1154 { 1155 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1156 sb_error.SetError(process_sp->GetWatchpointSupportInfo (num)); 1157 if (log) 1158 log->Printf ("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u", 1159 process_sp.get(), num); 1160 } 1161 else 1162 { 1163 sb_error.SetErrorString ("SBProcess is invalid"); 1164 } 1165 return num; 1166 } 1167 1168 uint32_t 1169 SBProcess::LoadImage (lldb::SBFileSpec &sb_image_spec, lldb::SBError &sb_error) 1170 { 1171 ProcessSP process_sp(GetSP()); 1172 if (process_sp) 1173 { 1174 Process::StopLocker stop_locker; 1175 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1176 { 1177 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1178 return process_sp->LoadImage (*sb_image_spec, sb_error.ref()); 1179 } 1180 else 1181 { 1182 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1183 if (log) 1184 log->Printf ("SBProcess(%p)::LoadImage() => error: process is running", process_sp.get()); 1185 sb_error.SetErrorString("process is running"); 1186 } 1187 } 1188 return LLDB_INVALID_IMAGE_TOKEN; 1189 } 1190 1191 lldb::SBError 1192 SBProcess::UnloadImage (uint32_t image_token) 1193 { 1194 lldb::SBError sb_error; 1195 ProcessSP process_sp(GetSP()); 1196 if (process_sp) 1197 { 1198 Process::StopLocker stop_locker; 1199 if (stop_locker.TryLock(&process_sp->GetRunLock())) 1200 { 1201 Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex()); 1202 sb_error.SetError (process_sp->UnloadImage (image_token)); 1203 } 1204 else 1205 { 1206 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1207 if (log) 1208 log->Printf ("SBProcess(%p)::UnloadImage() => error: process is running", process_sp.get()); 1209 sb_error.SetErrorString("process is running"); 1210 } 1211 } 1212 else 1213 sb_error.SetErrorString("invalid process"); 1214 return sb_error; 1215 } 1216