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