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