1 //===-- SBProcess.cpp -------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/API/SBProcess.h" 10 #include "SBReproducerPrivate.h" 11 12 #include <inttypes.h> 13 14 #include "lldb/lldb-defines.h" 15 #include "lldb/lldb-types.h" 16 17 #include "lldb/Core/Debugger.h" 18 #include "lldb/Core/Module.h" 19 #include "lldb/Core/PluginManager.h" 20 #include "lldb/Core/StreamFile.h" 21 #include "lldb/Target/MemoryRegionInfo.h" 22 #include "lldb/Target/Process.h" 23 #include "lldb/Target/RegisterContext.h" 24 #include "lldb/Target/SystemRuntime.h" 25 #include "lldb/Target/Target.h" 26 #include "lldb/Target/Thread.h" 27 #include "lldb/Utility/Args.h" 28 #include "lldb/Utility/Log.h" 29 #include "lldb/Utility/ProcessInfo.h" 30 #include "lldb/Utility/State.h" 31 #include "lldb/Utility/Stream.h" 32 33 34 #include "lldb/API/SBBroadcaster.h" 35 #include "lldb/API/SBCommandReturnObject.h" 36 #include "lldb/API/SBDebugger.h" 37 #include "lldb/API/SBEvent.h" 38 #include "lldb/API/SBFileSpec.h" 39 #include "lldb/API/SBMemoryRegionInfo.h" 40 #include "lldb/API/SBMemoryRegionInfoList.h" 41 #include "lldb/API/SBStream.h" 42 #include "lldb/API/SBStringList.h" 43 #include "lldb/API/SBStructuredData.h" 44 #include "lldb/API/SBThread.h" 45 #include "lldb/API/SBThreadCollection.h" 46 #include "lldb/API/SBTrace.h" 47 #include "lldb/API/SBTraceOptions.h" 48 #include "lldb/API/SBUnixSignals.h" 49 50 using namespace lldb; 51 using namespace lldb_private; 52 53 SBProcess::SBProcess() : m_opaque_wp() { 54 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcess); 55 } 56 57 //---------------------------------------------------------------------- 58 // SBProcess constructor 59 //---------------------------------------------------------------------- 60 61 SBProcess::SBProcess(const SBProcess &rhs) : m_opaque_wp(rhs.m_opaque_wp) { 62 LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::SBProcess &), rhs); 63 } 64 65 SBProcess::SBProcess(const lldb::ProcessSP &process_sp) 66 : m_opaque_wp(process_sp) { 67 LLDB_RECORD_CONSTRUCTOR(SBProcess, (const lldb::ProcessSP &), process_sp); 68 } 69 70 const SBProcess &SBProcess::operator=(const SBProcess &rhs) { 71 LLDB_RECORD_METHOD(const lldb::SBProcess &, 72 SBProcess, operator=,(const lldb::SBProcess &), rhs); 73 74 if (this != &rhs) 75 m_opaque_wp = rhs.m_opaque_wp; 76 return *this; 77 } 78 79 //---------------------------------------------------------------------- 80 // Destructor 81 //---------------------------------------------------------------------- 82 SBProcess::~SBProcess() {} 83 84 const char *SBProcess::GetBroadcasterClassName() { 85 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, 86 GetBroadcasterClassName); 87 88 return Process::GetStaticBroadcasterClass().AsCString(); 89 } 90 91 const char *SBProcess::GetPluginName() { 92 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetPluginName); 93 94 ProcessSP process_sp(GetSP()); 95 if (process_sp) { 96 return process_sp->GetPluginName().GetCString(); 97 } 98 return "<Unknown>"; 99 } 100 101 const char *SBProcess::GetShortPluginName() { 102 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetShortPluginName); 103 104 ProcessSP process_sp(GetSP()); 105 if (process_sp) { 106 return process_sp->GetPluginName().GetCString(); 107 } 108 return "<Unknown>"; 109 } 110 111 lldb::ProcessSP SBProcess::GetSP() const { return m_opaque_wp.lock(); } 112 113 void SBProcess::SetSP(const ProcessSP &process_sp) { m_opaque_wp = process_sp; } 114 115 void SBProcess::Clear() { 116 LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, Clear); 117 118 m_opaque_wp.reset(); 119 } 120 121 bool SBProcess::IsValid() const { 122 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcess, IsValid); 123 124 ProcessSP process_sp(m_opaque_wp.lock()); 125 return ((bool)process_sp && process_sp->IsValid()); 126 } 127 128 bool SBProcess::RemoteLaunch(char const **argv, char const **envp, 129 const char *stdin_path, const char *stdout_path, 130 const char *stderr_path, 131 const char *working_directory, 132 uint32_t launch_flags, bool stop_at_entry, 133 lldb::SBError &error) { 134 LLDB_RECORD_METHOD(bool, SBProcess, RemoteLaunch, 135 (const char **, const char **, const char *, const char *, 136 const char *, const char *, uint32_t, bool, 137 lldb::SBError &), 138 argv, envp, stdin_path, stdout_path, stderr_path, 139 working_directory, launch_flags, stop_at_entry, error); 140 141 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 142 if (log) 143 log->Printf("SBProcess(%p)::RemoteLaunch (argv=%p, envp=%p, stdin=%s, " 144 "stdout=%s, stderr=%s, working-dir=%s, launch_flags=0x%x, " 145 "stop_at_entry=%i, &error (%p))...", 146 static_cast<void *>(m_opaque_wp.lock().get()), 147 static_cast<void *>(argv), static_cast<void *>(envp), 148 stdin_path ? stdin_path : "NULL", 149 stdout_path ? stdout_path : "NULL", 150 stderr_path ? stderr_path : "NULL", 151 working_directory ? working_directory : "NULL", launch_flags, 152 stop_at_entry, static_cast<void *>(error.get())); 153 154 ProcessSP process_sp(GetSP()); 155 if (process_sp) { 156 std::lock_guard<std::recursive_mutex> guard( 157 process_sp->GetTarget().GetAPIMutex()); 158 if (process_sp->GetState() == eStateConnected) { 159 if (stop_at_entry) 160 launch_flags |= eLaunchFlagStopAtEntry; 161 ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path), 162 FileSpec(stderr_path), 163 FileSpec(working_directory), launch_flags); 164 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 165 if (exe_module) 166 launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true); 167 if (argv) 168 launch_info.GetArguments().AppendArguments(argv); 169 if (envp) 170 launch_info.GetEnvironment() = Environment(envp); 171 error.SetError(process_sp->Launch(launch_info)); 172 } else { 173 error.SetErrorString("must be in eStateConnected to call RemoteLaunch"); 174 } 175 } else { 176 error.SetErrorString("unable to attach pid"); 177 } 178 179 if (log) { 180 SBStream sstr; 181 error.GetDescription(sstr); 182 log->Printf("SBProcess(%p)::RemoteLaunch (...) => SBError (%p): %s", 183 static_cast<void *>(process_sp.get()), 184 static_cast<void *>(error.get()), sstr.GetData()); 185 } 186 187 return error.Success(); 188 } 189 190 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid, 191 lldb::SBError &error) { 192 LLDB_RECORD_METHOD(bool, SBProcess, RemoteAttachToProcessWithID, 193 (lldb::pid_t, lldb::SBError &), pid, error); 194 195 ProcessSP process_sp(GetSP()); 196 if (process_sp) { 197 std::lock_guard<std::recursive_mutex> guard( 198 process_sp->GetTarget().GetAPIMutex()); 199 if (process_sp->GetState() == eStateConnected) { 200 ProcessAttachInfo attach_info; 201 attach_info.SetProcessID(pid); 202 error.SetError(process_sp->Attach(attach_info)); 203 } else { 204 error.SetErrorString( 205 "must be in eStateConnected to call RemoteAttachToProcessWithID"); 206 } 207 } else { 208 error.SetErrorString("unable to attach pid"); 209 } 210 211 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 212 if (log) { 213 SBStream sstr; 214 error.GetDescription(sstr); 215 log->Printf("SBProcess(%p)::RemoteAttachToProcessWithID (%" PRIu64 216 ") => SBError (%p): %s", 217 static_cast<void *>(process_sp.get()), pid, 218 static_cast<void *>(error.get()), sstr.GetData()); 219 } 220 221 return error.Success(); 222 } 223 224 uint32_t SBProcess::GetNumThreads() { 225 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumThreads); 226 227 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 228 229 uint32_t num_threads = 0; 230 ProcessSP process_sp(GetSP()); 231 if (process_sp) { 232 Process::StopLocker stop_locker; 233 234 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 235 std::lock_guard<std::recursive_mutex> guard( 236 process_sp->GetTarget().GetAPIMutex()); 237 num_threads = process_sp->GetThreadList().GetSize(can_update); 238 } 239 240 if (log) 241 log->Printf("SBProcess(%p)::GetNumThreads () => %d", 242 static_cast<void *>(process_sp.get()), num_threads); 243 244 return num_threads; 245 } 246 247 SBThread SBProcess::GetSelectedThread() const { 248 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBThread, SBProcess, 249 GetSelectedThread); 250 251 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 252 253 SBThread sb_thread; 254 ThreadSP thread_sp; 255 ProcessSP process_sp(GetSP()); 256 if (process_sp) { 257 std::lock_guard<std::recursive_mutex> guard( 258 process_sp->GetTarget().GetAPIMutex()); 259 thread_sp = process_sp->GetThreadList().GetSelectedThread(); 260 sb_thread.SetThread(thread_sp); 261 } 262 263 if (log) 264 log->Printf("SBProcess(%p)::GetSelectedThread () => SBThread(%p)", 265 static_cast<void *>(process_sp.get()), 266 static_cast<void *>(thread_sp.get())); 267 268 return LLDB_RECORD_RESULT(sb_thread); 269 } 270 271 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid, 272 lldb::addr_t context) { 273 LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, CreateOSPluginThread, 274 (lldb::tid_t, lldb::addr_t), tid, context); 275 276 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 277 278 SBThread sb_thread; 279 ThreadSP thread_sp; 280 ProcessSP process_sp(GetSP()); 281 if (process_sp) { 282 std::lock_guard<std::recursive_mutex> guard( 283 process_sp->GetTarget().GetAPIMutex()); 284 thread_sp = process_sp->CreateOSPluginThread(tid, context); 285 sb_thread.SetThread(thread_sp); 286 } 287 288 if (log) 289 log->Printf("SBProcess(%p)::CreateOSPluginThread (tid=0x%" PRIx64 290 ", context=0x%" PRIx64 ") => SBThread(%p)", 291 static_cast<void *>(process_sp.get()), tid, context, 292 static_cast<void *>(thread_sp.get())); 293 294 return LLDB_RECORD_RESULT(sb_thread); 295 } 296 297 SBTarget SBProcess::GetTarget() const { 298 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBTarget, SBProcess, GetTarget); 299 300 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 301 302 SBTarget sb_target; 303 TargetSP target_sp; 304 ProcessSP process_sp(GetSP()); 305 if (process_sp) { 306 target_sp = process_sp->GetTarget().shared_from_this(); 307 sb_target.SetSP(target_sp); 308 } 309 310 if (log) 311 log->Printf("SBProcess(%p)::GetTarget () => SBTarget(%p)", 312 static_cast<void *>(process_sp.get()), 313 static_cast<void *>(target_sp.get())); 314 315 return LLDB_RECORD_RESULT(sb_target); 316 } 317 318 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) { 319 LLDB_RECORD_METHOD(size_t, SBProcess, PutSTDIN, (const char *, size_t), src, 320 src_len); 321 322 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 323 324 size_t ret_val = 0; 325 ProcessSP process_sp(GetSP()); 326 if (process_sp) { 327 Status error; 328 ret_val = process_sp->PutSTDIN(src, src_len, error); 329 } 330 331 if (log) 332 log->Printf("SBProcess(%p)::PutSTDIN (src=\"%s\", src_len=%" PRIu64 333 ") => %" PRIu64, 334 static_cast<void *>(process_sp.get()), src, 335 static_cast<uint64_t>(src_len), static_cast<uint64_t>(ret_val)); 336 337 return ret_val; 338 } 339 340 size_t SBProcess::GetSTDOUT(char *dst, size_t dst_len) const { 341 LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDOUT, (char *, size_t), dst, 342 dst_len); 343 344 size_t bytes_read = 0; 345 ProcessSP process_sp(GetSP()); 346 if (process_sp) { 347 Status error; 348 bytes_read = process_sp->GetSTDOUT(dst, dst_len, error); 349 } 350 351 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 352 if (log) 353 log->Printf( 354 "SBProcess(%p)::GetSTDOUT (dst=\"%.*s\", dst_len=%" PRIu64 355 ") => %" PRIu64, 356 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 357 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 358 359 return bytes_read; 360 } 361 362 size_t SBProcess::GetSTDERR(char *dst, size_t dst_len) const { 363 LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetSTDERR, (char *, size_t), dst, 364 dst_len); 365 366 size_t bytes_read = 0; 367 ProcessSP process_sp(GetSP()); 368 if (process_sp) { 369 Status error; 370 bytes_read = process_sp->GetSTDERR(dst, dst_len, error); 371 } 372 373 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 374 if (log) 375 log->Printf( 376 "SBProcess(%p)::GetSTDERR (dst=\"%.*s\", dst_len=%" PRIu64 377 ") => %" PRIu64, 378 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 379 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 380 381 return bytes_read; 382 } 383 384 size_t SBProcess::GetAsyncProfileData(char *dst, size_t dst_len) const { 385 LLDB_RECORD_METHOD_CONST(size_t, SBProcess, GetAsyncProfileData, 386 (char *, size_t), dst, dst_len); 387 388 size_t bytes_read = 0; 389 ProcessSP process_sp(GetSP()); 390 if (process_sp) { 391 Status error; 392 bytes_read = process_sp->GetAsyncProfileData(dst, dst_len, error); 393 } 394 395 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 396 if (log) 397 log->Printf( 398 "SBProcess(%p)::GetAsyncProfileData (dst=\"%.*s\", dst_len=%" PRIu64 399 ") => %" PRIu64, 400 static_cast<void *>(process_sp.get()), static_cast<int>(bytes_read), 401 dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(bytes_read)); 402 403 return bytes_read; 404 } 405 406 lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options, 407 lldb::SBError &error) { 408 LLDB_RECORD_METHOD(lldb::SBTrace, SBProcess, StartTrace, 409 (lldb::SBTraceOptions &, lldb::SBError &), options, error); 410 411 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 412 ProcessSP process_sp(GetSP()); 413 error.Clear(); 414 SBTrace trace_instance; 415 trace_instance.SetSP(process_sp); 416 lldb::user_id_t uid = LLDB_INVALID_UID; 417 418 if (!process_sp) { 419 error.SetErrorString("invalid process"); 420 } else { 421 uid = process_sp->StartTrace(*(options.m_traceoptions_sp), error.ref()); 422 trace_instance.SetTraceUID(uid); 423 LLDB_LOG(log, "SBProcess::returned uid - {0}", uid); 424 } 425 return LLDB_RECORD_RESULT(trace_instance); 426 } 427 428 void SBProcess::ReportEventState(const SBEvent &event, FILE *out) const { 429 LLDB_RECORD_METHOD_CONST(void, SBProcess, ReportEventState, 430 (const lldb::SBEvent &, FILE *), event, out); 431 432 if (out == NULL) 433 return; 434 435 ProcessSP process_sp(GetSP()); 436 if (process_sp) { 437 const StateType event_state = SBProcess::GetStateFromEvent(event); 438 char message[1024]; 439 int message_len = ::snprintf( 440 message, sizeof(message), "Process %" PRIu64 " %s\n", 441 process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 442 443 if (message_len > 0) 444 ::fwrite(message, 1, message_len, out); 445 } 446 } 447 448 void SBProcess::AppendEventStateReport(const SBEvent &event, 449 SBCommandReturnObject &result) { 450 LLDB_RECORD_METHOD(void, SBProcess, AppendEventStateReport, 451 (const lldb::SBEvent &, lldb::SBCommandReturnObject &), 452 event, result); 453 454 ProcessSP process_sp(GetSP()); 455 if (process_sp) { 456 const StateType event_state = SBProcess::GetStateFromEvent(event); 457 char message[1024]; 458 ::snprintf(message, sizeof(message), "Process %" PRIu64 " %s\n", 459 process_sp->GetID(), SBDebugger::StateAsCString(event_state)); 460 461 result.AppendMessage(message); 462 } 463 } 464 465 bool SBProcess::SetSelectedThread(const SBThread &thread) { 466 LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThread, 467 (const lldb::SBThread &), thread); 468 469 ProcessSP process_sp(GetSP()); 470 if (process_sp) { 471 std::lock_guard<std::recursive_mutex> guard( 472 process_sp->GetTarget().GetAPIMutex()); 473 return process_sp->GetThreadList().SetSelectedThreadByID( 474 thread.GetThreadID()); 475 } 476 return false; 477 } 478 479 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) { 480 LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByID, (lldb::tid_t), 481 tid); 482 483 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 484 485 bool ret_val = false; 486 ProcessSP process_sp(GetSP()); 487 if (process_sp) { 488 std::lock_guard<std::recursive_mutex> guard( 489 process_sp->GetTarget().GetAPIMutex()); 490 ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid); 491 } 492 493 if (log) 494 log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%4.4" PRIx64 495 ") => %s", 496 static_cast<void *>(process_sp.get()), tid, 497 (ret_val ? "true" : "false")); 498 499 return ret_val; 500 } 501 502 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) { 503 LLDB_RECORD_METHOD(bool, SBProcess, SetSelectedThreadByIndexID, (uint32_t), 504 index_id); 505 506 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 507 508 bool ret_val = false; 509 ProcessSP process_sp(GetSP()); 510 if (process_sp) { 511 std::lock_guard<std::recursive_mutex> guard( 512 process_sp->GetTarget().GetAPIMutex()); 513 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id); 514 } 515 516 if (log) 517 log->Printf("SBProcess(%p)::SetSelectedThreadByID (tid=0x%x) => %s", 518 static_cast<void *>(process_sp.get()), index_id, 519 (ret_val ? "true" : "false")); 520 521 return ret_val; 522 } 523 524 SBThread SBProcess::GetThreadAtIndex(size_t index) { 525 LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadAtIndex, (size_t), 526 index); 527 528 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 529 530 SBThread sb_thread; 531 ThreadSP thread_sp; 532 ProcessSP process_sp(GetSP()); 533 if (process_sp) { 534 Process::StopLocker stop_locker; 535 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 536 std::lock_guard<std::recursive_mutex> guard( 537 process_sp->GetTarget().GetAPIMutex()); 538 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update); 539 sb_thread.SetThread(thread_sp); 540 } 541 542 if (log) 543 log->Printf("SBProcess(%p)::GetThreadAtIndex (index=%d) => SBThread(%p)", 544 static_cast<void *>(process_sp.get()), 545 static_cast<uint32_t>(index), 546 static_cast<void *>(thread_sp.get())); 547 548 return LLDB_RECORD_RESULT(sb_thread); 549 } 550 551 uint32_t SBProcess::GetNumQueues() { 552 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumQueues); 553 554 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 555 556 uint32_t num_queues = 0; 557 ProcessSP process_sp(GetSP()); 558 if (process_sp) { 559 Process::StopLocker stop_locker; 560 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 561 std::lock_guard<std::recursive_mutex> guard( 562 process_sp->GetTarget().GetAPIMutex()); 563 num_queues = process_sp->GetQueueList().GetSize(); 564 } 565 } 566 567 if (log) 568 log->Printf("SBProcess(%p)::GetNumQueues () => %d", 569 static_cast<void *>(process_sp.get()), num_queues); 570 571 return num_queues; 572 } 573 574 SBQueue SBProcess::GetQueueAtIndex(size_t index) { 575 LLDB_RECORD_METHOD(lldb::SBQueue, SBProcess, GetQueueAtIndex, (size_t), 576 index); 577 578 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 579 580 SBQueue sb_queue; 581 QueueSP queue_sp; 582 ProcessSP process_sp(GetSP()); 583 if (process_sp) { 584 Process::StopLocker stop_locker; 585 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 586 std::lock_guard<std::recursive_mutex> guard( 587 process_sp->GetTarget().GetAPIMutex()); 588 queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index); 589 sb_queue.SetQueue(queue_sp); 590 } 591 } 592 593 if (log) 594 log->Printf("SBProcess(%p)::GetQueueAtIndex (index=%d) => SBQueue(%p)", 595 static_cast<void *>(process_sp.get()), 596 static_cast<uint32_t>(index), 597 static_cast<void *>(queue_sp.get())); 598 599 return LLDB_RECORD_RESULT(sb_queue); 600 } 601 602 uint32_t SBProcess::GetStopID(bool include_expression_stops) { 603 LLDB_RECORD_METHOD(uint32_t, SBProcess, GetStopID, (bool), 604 include_expression_stops); 605 606 ProcessSP process_sp(GetSP()); 607 if (process_sp) { 608 std::lock_guard<std::recursive_mutex> guard( 609 process_sp->GetTarget().GetAPIMutex()); 610 if (include_expression_stops) 611 return process_sp->GetStopID(); 612 else 613 return process_sp->GetLastNaturalStopID(); 614 } 615 return 0; 616 } 617 618 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) { 619 LLDB_RECORD_METHOD(lldb::SBEvent, SBProcess, GetStopEventForStopID, 620 (uint32_t), stop_id); 621 622 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 623 624 SBEvent sb_event; 625 EventSP event_sp; 626 ProcessSP process_sp(GetSP()); 627 if (process_sp) { 628 std::lock_guard<std::recursive_mutex> guard( 629 process_sp->GetTarget().GetAPIMutex()); 630 event_sp = process_sp->GetStopEventForStopID(stop_id); 631 sb_event.reset(event_sp); 632 } 633 634 if (log) 635 log->Printf("SBProcess(%p)::GetStopEventForStopID (stop_id=%" PRIu32 636 ") => SBEvent(%p)", 637 static_cast<void *>(process_sp.get()), stop_id, 638 static_cast<void *>(event_sp.get())); 639 640 return LLDB_RECORD_RESULT(sb_event); 641 } 642 643 StateType SBProcess::GetState() { 644 LLDB_RECORD_METHOD_NO_ARGS(lldb::StateType, SBProcess, GetState); 645 646 StateType ret_val = eStateInvalid; 647 ProcessSP process_sp(GetSP()); 648 if (process_sp) { 649 std::lock_guard<std::recursive_mutex> guard( 650 process_sp->GetTarget().GetAPIMutex()); 651 ret_val = process_sp->GetState(); 652 } 653 654 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 655 if (log) 656 log->Printf("SBProcess(%p)::GetState () => %s", 657 static_cast<void *>(process_sp.get()), 658 lldb_private::StateAsCString(ret_val)); 659 660 return ret_val; 661 } 662 663 int SBProcess::GetExitStatus() { 664 LLDB_RECORD_METHOD_NO_ARGS(int, SBProcess, GetExitStatus); 665 666 int exit_status = 0; 667 ProcessSP process_sp(GetSP()); 668 if (process_sp) { 669 std::lock_guard<std::recursive_mutex> guard( 670 process_sp->GetTarget().GetAPIMutex()); 671 exit_status = process_sp->GetExitStatus(); 672 } 673 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 674 if (log) 675 log->Printf("SBProcess(%p)::GetExitStatus () => %i (0x%8.8x)", 676 static_cast<void *>(process_sp.get()), exit_status, 677 exit_status); 678 679 return exit_status; 680 } 681 682 const char *SBProcess::GetExitDescription() { 683 LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcess, GetExitDescription); 684 685 const char *exit_desc = NULL; 686 ProcessSP process_sp(GetSP()); 687 if (process_sp) { 688 std::lock_guard<std::recursive_mutex> guard( 689 process_sp->GetTarget().GetAPIMutex()); 690 exit_desc = process_sp->GetExitDescription(); 691 } 692 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 693 if (log) 694 log->Printf("SBProcess(%p)::GetExitDescription () => %s", 695 static_cast<void *>(process_sp.get()), exit_desc); 696 return exit_desc; 697 } 698 699 lldb::pid_t SBProcess::GetProcessID() { 700 LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcess, GetProcessID); 701 702 lldb::pid_t ret_val = LLDB_INVALID_PROCESS_ID; 703 ProcessSP process_sp(GetSP()); 704 if (process_sp) 705 ret_val = process_sp->GetID(); 706 707 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 708 if (log) 709 log->Printf("SBProcess(%p)::GetProcessID () => %" PRIu64, 710 static_cast<void *>(process_sp.get()), ret_val); 711 712 return ret_val; 713 } 714 715 uint32_t SBProcess::GetUniqueID() { 716 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetUniqueID); 717 718 uint32_t ret_val = 0; 719 ProcessSP process_sp(GetSP()); 720 if (process_sp) 721 ret_val = process_sp->GetUniqueID(); 722 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 723 if (log) 724 log->Printf("SBProcess(%p)::GetUniqueID () => %" PRIu32, 725 static_cast<void *>(process_sp.get()), ret_val); 726 return ret_val; 727 } 728 729 ByteOrder SBProcess::GetByteOrder() const { 730 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ByteOrder, SBProcess, GetByteOrder); 731 732 ByteOrder byteOrder = eByteOrderInvalid; 733 ProcessSP process_sp(GetSP()); 734 if (process_sp) 735 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder(); 736 737 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 738 if (log) 739 log->Printf("SBProcess(%p)::GetByteOrder () => %d", 740 static_cast<void *>(process_sp.get()), byteOrder); 741 742 return byteOrder; 743 } 744 745 uint32_t SBProcess::GetAddressByteSize() const { 746 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBProcess, GetAddressByteSize); 747 748 uint32_t size = 0; 749 ProcessSP process_sp(GetSP()); 750 if (process_sp) 751 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize(); 752 753 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 754 if (log) 755 log->Printf("SBProcess(%p)::GetAddressByteSize () => %d", 756 static_cast<void *>(process_sp.get()), size); 757 758 return size; 759 } 760 761 SBError SBProcess::Continue() { 762 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Continue); 763 764 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 765 766 SBError sb_error; 767 ProcessSP process_sp(GetSP()); 768 769 if (log) 770 log->Printf("SBProcess(%p)::Continue ()...", 771 static_cast<void *>(process_sp.get())); 772 773 if (process_sp) { 774 std::lock_guard<std::recursive_mutex> guard( 775 process_sp->GetTarget().GetAPIMutex()); 776 777 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution()) 778 sb_error.ref() = process_sp->Resume(); 779 else 780 sb_error.ref() = process_sp->ResumeSynchronous(NULL); 781 } else 782 sb_error.SetErrorString("SBProcess is invalid"); 783 784 if (log) { 785 SBStream sstr; 786 sb_error.GetDescription(sstr); 787 log->Printf("SBProcess(%p)::Continue () => SBError (%p): %s", 788 static_cast<void *>(process_sp.get()), 789 static_cast<void *>(sb_error.get()), sstr.GetData()); 790 } 791 792 return LLDB_RECORD_RESULT(sb_error); 793 } 794 795 SBError SBProcess::Destroy() { 796 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Destroy); 797 798 SBError sb_error; 799 ProcessSP process_sp(GetSP()); 800 if (process_sp) { 801 std::lock_guard<std::recursive_mutex> guard( 802 process_sp->GetTarget().GetAPIMutex()); 803 sb_error.SetError(process_sp->Destroy(false)); 804 } else 805 sb_error.SetErrorString("SBProcess is invalid"); 806 807 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 808 if (log) { 809 SBStream sstr; 810 sb_error.GetDescription(sstr); 811 log->Printf("SBProcess(%p)::Destroy () => SBError (%p): %s", 812 static_cast<void *>(process_sp.get()), 813 static_cast<void *>(sb_error.get()), sstr.GetData()); 814 } 815 816 return LLDB_RECORD_RESULT(sb_error); 817 } 818 819 SBError SBProcess::Stop() { 820 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Stop); 821 822 SBError sb_error; 823 ProcessSP process_sp(GetSP()); 824 if (process_sp) { 825 std::lock_guard<std::recursive_mutex> guard( 826 process_sp->GetTarget().GetAPIMutex()); 827 sb_error.SetError(process_sp->Halt()); 828 } else 829 sb_error.SetErrorString("SBProcess is invalid"); 830 831 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 832 if (log) { 833 SBStream sstr; 834 sb_error.GetDescription(sstr); 835 log->Printf("SBProcess(%p)::Stop () => SBError (%p): %s", 836 static_cast<void *>(process_sp.get()), 837 static_cast<void *>(sb_error.get()), sstr.GetData()); 838 } 839 840 return LLDB_RECORD_RESULT(sb_error); 841 } 842 843 SBError SBProcess::Kill() { 844 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Kill); 845 846 SBError sb_error; 847 ProcessSP process_sp(GetSP()); 848 if (process_sp) { 849 std::lock_guard<std::recursive_mutex> guard( 850 process_sp->GetTarget().GetAPIMutex()); 851 sb_error.SetError(process_sp->Destroy(true)); 852 } else 853 sb_error.SetErrorString("SBProcess is invalid"); 854 855 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 856 if (log) { 857 SBStream sstr; 858 sb_error.GetDescription(sstr); 859 log->Printf("SBProcess(%p)::Kill () => SBError (%p): %s", 860 static_cast<void *>(process_sp.get()), 861 static_cast<void *>(sb_error.get()), sstr.GetData()); 862 } 863 864 return LLDB_RECORD_RESULT(sb_error); 865 } 866 867 SBError SBProcess::Detach() { 868 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBError, SBProcess, Detach); 869 870 // FIXME: This should come from a process default. 871 bool keep_stopped = false; 872 return LLDB_RECORD_RESULT(Detach(keep_stopped)); 873 } 874 875 SBError SBProcess::Detach(bool keep_stopped) { 876 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Detach, (bool), keep_stopped); 877 878 SBError sb_error; 879 ProcessSP process_sp(GetSP()); 880 if (process_sp) { 881 std::lock_guard<std::recursive_mutex> guard( 882 process_sp->GetTarget().GetAPIMutex()); 883 sb_error.SetError(process_sp->Detach(keep_stopped)); 884 } else 885 sb_error.SetErrorString("SBProcess is invalid"); 886 887 return LLDB_RECORD_RESULT(sb_error); 888 } 889 890 SBError SBProcess::Signal(int signo) { 891 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, Signal, (int), signo); 892 893 SBError sb_error; 894 ProcessSP process_sp(GetSP()); 895 if (process_sp) { 896 std::lock_guard<std::recursive_mutex> guard( 897 process_sp->GetTarget().GetAPIMutex()); 898 sb_error.SetError(process_sp->Signal(signo)); 899 } else 900 sb_error.SetErrorString("SBProcess is invalid"); 901 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 902 if (log) { 903 SBStream sstr; 904 sb_error.GetDescription(sstr); 905 log->Printf("SBProcess(%p)::Signal (signo=%i) => SBError (%p): %s", 906 static_cast<void *>(process_sp.get()), signo, 907 static_cast<void *>(sb_error.get()), sstr.GetData()); 908 } 909 return LLDB_RECORD_RESULT(sb_error); 910 } 911 912 SBUnixSignals SBProcess::GetUnixSignals() { 913 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBUnixSignals, SBProcess, GetUnixSignals); 914 915 if (auto process_sp = GetSP()) 916 return LLDB_RECORD_RESULT(SBUnixSignals{process_sp}); 917 918 return LLDB_RECORD_RESULT(SBUnixSignals{}); 919 } 920 921 void SBProcess::SendAsyncInterrupt() { 922 LLDB_RECORD_METHOD_NO_ARGS(void, SBProcess, SendAsyncInterrupt); 923 924 ProcessSP process_sp(GetSP()); 925 if (process_sp) { 926 process_sp->SendAsyncInterrupt(); 927 } 928 } 929 930 SBThread SBProcess::GetThreadByID(tid_t tid) { 931 LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByID, (lldb::tid_t), 932 tid); 933 934 SBThread sb_thread; 935 ThreadSP thread_sp; 936 ProcessSP process_sp(GetSP()); 937 if (process_sp) { 938 Process::StopLocker stop_locker; 939 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 940 std::lock_guard<std::recursive_mutex> guard( 941 process_sp->GetTarget().GetAPIMutex()); 942 thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update); 943 sb_thread.SetThread(thread_sp); 944 } 945 946 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 947 if (log) 948 log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%4.4" PRIx64 949 ") => SBThread (%p)", 950 static_cast<void *>(process_sp.get()), tid, 951 static_cast<void *>(thread_sp.get())); 952 953 return LLDB_RECORD_RESULT(sb_thread); 954 } 955 956 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) { 957 LLDB_RECORD_METHOD(lldb::SBThread, SBProcess, GetThreadByIndexID, (uint32_t), 958 index_id); 959 960 SBThread sb_thread; 961 ThreadSP thread_sp; 962 ProcessSP process_sp(GetSP()); 963 if (process_sp) { 964 Process::StopLocker stop_locker; 965 const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock()); 966 std::lock_guard<std::recursive_mutex> guard( 967 process_sp->GetTarget().GetAPIMutex()); 968 thread_sp = 969 process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update); 970 sb_thread.SetThread(thread_sp); 971 } 972 973 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 974 if (log) 975 log->Printf("SBProcess(%p)::GetThreadByID (tid=0x%x) => SBThread (%p)", 976 static_cast<void *>(process_sp.get()), index_id, 977 static_cast<void *>(thread_sp.get())); 978 979 return LLDB_RECORD_RESULT(sb_thread); 980 } 981 982 StateType SBProcess::GetStateFromEvent(const SBEvent &event) { 983 LLDB_RECORD_STATIC_METHOD(lldb::StateType, SBProcess, GetStateFromEvent, 984 (const lldb::SBEvent &), event); 985 986 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 987 988 StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.get()); 989 990 if (log) 991 log->Printf("SBProcess::GetStateFromEvent (event.sp=%p) => %s", 992 static_cast<void *>(event.get()), 993 lldb_private::StateAsCString(ret_val)); 994 995 return ret_val; 996 } 997 998 bool SBProcess::GetRestartedFromEvent(const SBEvent &event) { 999 LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetRestartedFromEvent, 1000 (const lldb::SBEvent &), event); 1001 1002 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1003 1004 bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.get()); 1005 1006 if (log) 1007 log->Printf("SBProcess::%s (event.sp=%p) => %d", __FUNCTION__, 1008 static_cast<void *>(event.get()), ret_val); 1009 1010 return ret_val; 1011 } 1012 1013 size_t SBProcess::GetNumRestartedReasonsFromEvent(const lldb::SBEvent &event) { 1014 LLDB_RECORD_STATIC_METHOD(size_t, SBProcess, GetNumRestartedReasonsFromEvent, 1015 (const lldb::SBEvent &), event); 1016 1017 return Process::ProcessEventData::GetNumRestartedReasons(event.get()); 1018 } 1019 1020 const char * 1021 SBProcess::GetRestartedReasonAtIndexFromEvent(const lldb::SBEvent &event, 1022 size_t idx) { 1023 LLDB_RECORD_STATIC_METHOD(const char *, SBProcess, 1024 GetRestartedReasonAtIndexFromEvent, 1025 (const lldb::SBEvent &, size_t), event, idx); 1026 1027 return Process::ProcessEventData::GetRestartedReasonAtIndex(event.get(), idx); 1028 } 1029 1030 SBProcess SBProcess::GetProcessFromEvent(const SBEvent &event) { 1031 LLDB_RECORD_STATIC_METHOD(lldb::SBProcess, SBProcess, GetProcessFromEvent, 1032 (const lldb::SBEvent &), event); 1033 1034 ProcessSP process_sp = 1035 Process::ProcessEventData::GetProcessFromEvent(event.get()); 1036 if (!process_sp) { 1037 // StructuredData events also know the process they come from. Try that. 1038 process_sp = EventDataStructuredData::GetProcessFromEvent(event.get()); 1039 } 1040 1041 return LLDB_RECORD_RESULT(SBProcess(process_sp)); 1042 } 1043 1044 bool SBProcess::GetInterruptedFromEvent(const SBEvent &event) { 1045 LLDB_RECORD_STATIC_METHOD(bool, SBProcess, GetInterruptedFromEvent, 1046 (const lldb::SBEvent &), event); 1047 1048 return Process::ProcessEventData::GetInterruptedFromEvent(event.get()); 1049 } 1050 1051 lldb::SBStructuredData 1052 SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) { 1053 LLDB_RECORD_STATIC_METHOD(lldb::SBStructuredData, SBProcess, 1054 GetStructuredDataFromEvent, (const lldb::SBEvent &), 1055 event); 1056 1057 return LLDB_RECORD_RESULT(SBStructuredData(event.GetSP())); 1058 } 1059 1060 bool SBProcess::EventIsProcessEvent(const SBEvent &event) { 1061 LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsProcessEvent, 1062 (const lldb::SBEvent &), event); 1063 1064 return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) && 1065 !EventIsStructuredDataEvent(event); 1066 } 1067 1068 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) { 1069 LLDB_RECORD_STATIC_METHOD(bool, SBProcess, EventIsStructuredDataEvent, 1070 (const lldb::SBEvent &), event); 1071 1072 EventSP event_sp = event.GetSP(); 1073 EventData *event_data = event_sp ? event_sp->GetData() : nullptr; 1074 return event_data && (event_data->GetFlavor() == 1075 EventDataStructuredData::GetFlavorString()); 1076 } 1077 1078 SBBroadcaster SBProcess::GetBroadcaster() const { 1079 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBProcess, 1080 GetBroadcaster); 1081 1082 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1083 1084 ProcessSP process_sp(GetSP()); 1085 1086 SBBroadcaster broadcaster(process_sp.get(), false); 1087 1088 if (log) 1089 log->Printf("SBProcess(%p)::GetBroadcaster () => SBBroadcaster (%p)", 1090 static_cast<void *>(process_sp.get()), 1091 static_cast<void *>(broadcaster.get())); 1092 1093 return LLDB_RECORD_RESULT(broadcaster); 1094 } 1095 1096 const char *SBProcess::GetBroadcasterClass() { 1097 LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBProcess, 1098 GetBroadcasterClass); 1099 1100 return Process::GetStaticBroadcasterClass().AsCString(); 1101 } 1102 1103 size_t SBProcess::ReadMemory(addr_t addr, void *dst, size_t dst_len, 1104 SBError &sb_error) { 1105 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1106 1107 size_t bytes_read = 0; 1108 1109 ProcessSP process_sp(GetSP()); 1110 1111 if (log) 1112 log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 1113 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p))...", 1114 static_cast<void *>(process_sp.get()), addr, 1115 static_cast<void *>(dst), static_cast<uint64_t>(dst_len), 1116 static_cast<void *>(sb_error.get())); 1117 1118 if (process_sp) { 1119 Process::StopLocker stop_locker; 1120 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1121 std::lock_guard<std::recursive_mutex> guard( 1122 process_sp->GetTarget().GetAPIMutex()); 1123 bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.ref()); 1124 } else { 1125 if (log) 1126 log->Printf("SBProcess(%p)::ReadMemory() => error: process is running", 1127 static_cast<void *>(process_sp.get())); 1128 sb_error.SetErrorString("process is running"); 1129 } 1130 } else { 1131 sb_error.SetErrorString("SBProcess is invalid"); 1132 } 1133 1134 if (log) { 1135 SBStream sstr; 1136 sb_error.GetDescription(sstr); 1137 log->Printf("SBProcess(%p)::ReadMemory (addr=0x%" PRIx64 1138 ", dst=%p, dst_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 1139 static_cast<void *>(process_sp.get()), addr, 1140 static_cast<void *>(dst), static_cast<uint64_t>(dst_len), 1141 static_cast<void *>(sb_error.get()), sstr.GetData(), 1142 static_cast<uint64_t>(bytes_read)); 1143 } 1144 1145 return bytes_read; 1146 } 1147 1148 size_t SBProcess::ReadCStringFromMemory(addr_t addr, void *buf, size_t size, 1149 lldb::SBError &sb_error) { 1150 size_t bytes_read = 0; 1151 ProcessSP process_sp(GetSP()); 1152 if (process_sp) { 1153 Process::StopLocker stop_locker; 1154 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1155 std::lock_guard<std::recursive_mutex> guard( 1156 process_sp->GetTarget().GetAPIMutex()); 1157 bytes_read = process_sp->ReadCStringFromMemory(addr, (char *)buf, size, 1158 sb_error.ref()); 1159 } else { 1160 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1161 if (log) 1162 log->Printf("SBProcess(%p)::ReadCStringFromMemory() => error: process " 1163 "is running", 1164 static_cast<void *>(process_sp.get())); 1165 sb_error.SetErrorString("process is running"); 1166 } 1167 } else { 1168 sb_error.SetErrorString("SBProcess is invalid"); 1169 } 1170 return bytes_read; 1171 } 1172 1173 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size, 1174 lldb::SBError &sb_error) { 1175 LLDB_RECORD_METHOD(uint64_t, SBProcess, ReadUnsignedFromMemory, 1176 (lldb::addr_t, uint32_t, lldb::SBError &), addr, byte_size, 1177 sb_error); 1178 1179 uint64_t value = 0; 1180 ProcessSP process_sp(GetSP()); 1181 if (process_sp) { 1182 Process::StopLocker stop_locker; 1183 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1184 std::lock_guard<std::recursive_mutex> guard( 1185 process_sp->GetTarget().GetAPIMutex()); 1186 value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0, 1187 sb_error.ref()); 1188 } else { 1189 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1190 if (log) 1191 log->Printf("SBProcess(%p)::ReadUnsignedFromMemory() => error: process " 1192 "is running", 1193 static_cast<void *>(process_sp.get())); 1194 sb_error.SetErrorString("process is running"); 1195 } 1196 } else { 1197 sb_error.SetErrorString("SBProcess is invalid"); 1198 } 1199 return value; 1200 } 1201 1202 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr, 1203 lldb::SBError &sb_error) { 1204 LLDB_RECORD_METHOD(lldb::addr_t, SBProcess, ReadPointerFromMemory, 1205 (lldb::addr_t, lldb::SBError &), addr, sb_error); 1206 1207 lldb::addr_t ptr = LLDB_INVALID_ADDRESS; 1208 ProcessSP process_sp(GetSP()); 1209 if (process_sp) { 1210 Process::StopLocker stop_locker; 1211 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1212 std::lock_guard<std::recursive_mutex> guard( 1213 process_sp->GetTarget().GetAPIMutex()); 1214 ptr = process_sp->ReadPointerFromMemory(addr, sb_error.ref()); 1215 } else { 1216 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1217 if (log) 1218 log->Printf("SBProcess(%p)::ReadPointerFromMemory() => error: process " 1219 "is running", 1220 static_cast<void *>(process_sp.get())); 1221 sb_error.SetErrorString("process is running"); 1222 } 1223 } else { 1224 sb_error.SetErrorString("SBProcess is invalid"); 1225 } 1226 return ptr; 1227 } 1228 1229 size_t SBProcess::WriteMemory(addr_t addr, const void *src, size_t src_len, 1230 SBError &sb_error) { 1231 size_t bytes_written = 0; 1232 1233 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1234 1235 ProcessSP process_sp(GetSP()); 1236 1237 if (log) 1238 log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 1239 ", src=%p, src_len=%" PRIu64 ", SBError (%p))...", 1240 static_cast<void *>(process_sp.get()), addr, 1241 static_cast<const void *>(src), static_cast<uint64_t>(src_len), 1242 static_cast<void *>(sb_error.get())); 1243 1244 if (process_sp) { 1245 Process::StopLocker stop_locker; 1246 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1247 std::lock_guard<std::recursive_mutex> guard( 1248 process_sp->GetTarget().GetAPIMutex()); 1249 bytes_written = 1250 process_sp->WriteMemory(addr, src, src_len, sb_error.ref()); 1251 } else { 1252 if (log) 1253 log->Printf("SBProcess(%p)::WriteMemory() => error: process is running", 1254 static_cast<void *>(process_sp.get())); 1255 sb_error.SetErrorString("process is running"); 1256 } 1257 } 1258 1259 if (log) { 1260 SBStream sstr; 1261 sb_error.GetDescription(sstr); 1262 log->Printf("SBProcess(%p)::WriteMemory (addr=0x%" PRIx64 1263 ", src=%p, src_len=%" PRIu64 ", SBError (%p): %s) => %" PRIu64, 1264 static_cast<void *>(process_sp.get()), addr, 1265 static_cast<const void *>(src), static_cast<uint64_t>(src_len), 1266 static_cast<void *>(sb_error.get()), sstr.GetData(), 1267 static_cast<uint64_t>(bytes_written)); 1268 } 1269 1270 return bytes_written; 1271 } 1272 1273 bool SBProcess::GetDescription(SBStream &description) { 1274 LLDB_RECORD_METHOD(bool, SBProcess, GetDescription, (lldb::SBStream &), 1275 description); 1276 1277 Stream &strm = description.ref(); 1278 1279 ProcessSP process_sp(GetSP()); 1280 if (process_sp) { 1281 char path[PATH_MAX]; 1282 GetTarget().GetExecutable().GetPath(path, sizeof(path)); 1283 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer(); 1284 const char *exe_name = NULL; 1285 if (exe_module) 1286 exe_name = exe_module->GetFileSpec().GetFilename().AsCString(); 1287 1288 strm.Printf("SBProcess: pid = %" PRIu64 ", state = %s, threads = %d%s%s", 1289 process_sp->GetID(), lldb_private::StateAsCString(GetState()), 1290 GetNumThreads(), exe_name ? ", executable = " : "", 1291 exe_name ? exe_name : ""); 1292 } else 1293 strm.PutCString("No value"); 1294 1295 return true; 1296 } 1297 1298 uint32_t 1299 SBProcess::GetNumSupportedHardwareWatchpoints(lldb::SBError &sb_error) const { 1300 LLDB_RECORD_METHOD_CONST(uint32_t, SBProcess, 1301 GetNumSupportedHardwareWatchpoints, 1302 (lldb::SBError &), sb_error); 1303 1304 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1305 1306 uint32_t num = 0; 1307 ProcessSP process_sp(GetSP()); 1308 if (process_sp) { 1309 std::lock_guard<std::recursive_mutex> guard( 1310 process_sp->GetTarget().GetAPIMutex()); 1311 sb_error.SetError(process_sp->GetWatchpointSupportInfo(num)); 1312 if (log) 1313 log->Printf("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u", 1314 static_cast<void *>(process_sp.get()), num); 1315 } else { 1316 sb_error.SetErrorString("SBProcess is invalid"); 1317 } 1318 return num; 1319 } 1320 1321 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec, 1322 lldb::SBError &sb_error) { 1323 LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImage, 1324 (lldb::SBFileSpec &, lldb::SBError &), 1325 sb_remote_image_spec, sb_error); 1326 1327 return LoadImage(SBFileSpec(), sb_remote_image_spec, sb_error); 1328 } 1329 1330 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec, 1331 const lldb::SBFileSpec &sb_remote_image_spec, 1332 lldb::SBError &sb_error) { 1333 LLDB_RECORD_METHOD( 1334 uint32_t, SBProcess, LoadImage, 1335 (const lldb::SBFileSpec &, const lldb::SBFileSpec &, lldb::SBError &), 1336 sb_local_image_spec, sb_remote_image_spec, sb_error); 1337 1338 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1339 ProcessSP process_sp(GetSP()); 1340 if (process_sp) { 1341 Process::StopLocker stop_locker; 1342 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1343 if (log) 1344 log->Printf("SBProcess(%p)::LoadImage() => calling Platform::LoadImage" 1345 "for: %s", 1346 static_cast<void *>(process_sp.get()), 1347 sb_local_image_spec.GetFilename()); 1348 1349 std::lock_guard<std::recursive_mutex> guard( 1350 process_sp->GetTarget().GetAPIMutex()); 1351 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1352 return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec, 1353 *sb_remote_image_spec, sb_error.ref()); 1354 } else { 1355 if (log) 1356 log->Printf("SBProcess(%p)::LoadImage() => error: process is running", 1357 static_cast<void *>(process_sp.get())); 1358 sb_error.SetErrorString("process is running"); 1359 } 1360 } else { 1361 if (log) 1362 log->Printf("SBProcess(%p)::LoadImage() => error: called with invalid" 1363 " process", 1364 static_cast<void *>(process_sp.get())); 1365 sb_error.SetErrorString("process is invalid"); 1366 } 1367 return LLDB_INVALID_IMAGE_TOKEN; 1368 } 1369 1370 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec, 1371 SBStringList &paths, 1372 lldb::SBFileSpec &loaded_path, 1373 lldb::SBError &error) { 1374 LLDB_RECORD_METHOD(uint32_t, SBProcess, LoadImageUsingPaths, 1375 (const lldb::SBFileSpec &, lldb::SBStringList &, 1376 lldb::SBFileSpec &, lldb::SBError &), 1377 image_spec, paths, loaded_path, error); 1378 1379 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1380 ProcessSP process_sp(GetSP()); 1381 if (process_sp) { 1382 Process::StopLocker stop_locker; 1383 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1384 if (log) 1385 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => " 1386 "calling Platform::LoadImageUsingPaths for: %s", 1387 static_cast<void *>(process_sp.get()), 1388 image_spec.GetFilename()); 1389 1390 std::lock_guard<std::recursive_mutex> guard( 1391 process_sp->GetTarget().GetAPIMutex()); 1392 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1393 size_t num_paths = paths.GetSize(); 1394 std::vector<std::string> paths_vec; 1395 paths_vec.reserve(num_paths); 1396 for (size_t i = 0; i < num_paths; i++) 1397 paths_vec.push_back(paths.GetStringAtIndex(i)); 1398 FileSpec loaded_spec; 1399 1400 uint32_t token = platform_sp->LoadImageUsingPaths(process_sp.get(), 1401 *image_spec, 1402 paths_vec, 1403 error.ref(), 1404 &loaded_spec); 1405 if (token != LLDB_INVALID_IMAGE_TOKEN) 1406 loaded_path = loaded_spec; 1407 return token; 1408 } else { 1409 if (log) 1410 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " 1411 "process is running", 1412 static_cast<void *>(process_sp.get())); 1413 error.SetErrorString("process is running"); 1414 } 1415 } else { 1416 if (log) 1417 log->Printf("SBProcess(%p)::LoadImageUsingPaths() => error: " 1418 "called with invalid process", 1419 static_cast<void *>(process_sp.get())); 1420 error.SetErrorString("process is invalid"); 1421 } 1422 1423 return LLDB_INVALID_IMAGE_TOKEN; 1424 } 1425 1426 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) { 1427 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, UnloadImage, (uint32_t), 1428 image_token); 1429 1430 lldb::SBError sb_error; 1431 ProcessSP process_sp(GetSP()); 1432 if (process_sp) { 1433 Process::StopLocker stop_locker; 1434 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1435 std::lock_guard<std::recursive_mutex> guard( 1436 process_sp->GetTarget().GetAPIMutex()); 1437 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform(); 1438 sb_error.SetError( 1439 platform_sp->UnloadImage(process_sp.get(), image_token)); 1440 } else { 1441 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1442 if (log) 1443 log->Printf("SBProcess(%p)::UnloadImage() => error: process is running", 1444 static_cast<void *>(process_sp.get())); 1445 sb_error.SetErrorString("process is running"); 1446 } 1447 } else 1448 sb_error.SetErrorString("invalid process"); 1449 return LLDB_RECORD_RESULT(sb_error); 1450 } 1451 1452 lldb::SBError SBProcess::SendEventData(const char *event_data) { 1453 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SendEventData, (const char *), 1454 event_data); 1455 1456 lldb::SBError sb_error; 1457 ProcessSP process_sp(GetSP()); 1458 if (process_sp) { 1459 Process::StopLocker stop_locker; 1460 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1461 std::lock_guard<std::recursive_mutex> guard( 1462 process_sp->GetTarget().GetAPIMutex()); 1463 sb_error.SetError(process_sp->SendEventData(event_data)); 1464 } else { 1465 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1466 if (log) 1467 log->Printf( 1468 "SBProcess(%p)::SendEventData() => error: process is running", 1469 static_cast<void *>(process_sp.get())); 1470 sb_error.SetErrorString("process is running"); 1471 } 1472 } else 1473 sb_error.SetErrorString("invalid process"); 1474 return LLDB_RECORD_RESULT(sb_error); 1475 } 1476 1477 uint32_t SBProcess::GetNumExtendedBacktraceTypes() { 1478 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcess, GetNumExtendedBacktraceTypes); 1479 1480 ProcessSP process_sp(GetSP()); 1481 if (process_sp && process_sp->GetSystemRuntime()) { 1482 SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1483 return runtime->GetExtendedBacktraceTypes().size(); 1484 } 1485 return 0; 1486 } 1487 1488 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) { 1489 LLDB_RECORD_METHOD(const char *, SBProcess, GetExtendedBacktraceTypeAtIndex, 1490 (uint32_t), idx); 1491 1492 ProcessSP process_sp(GetSP()); 1493 if (process_sp && process_sp->GetSystemRuntime()) { 1494 SystemRuntime *runtime = process_sp->GetSystemRuntime(); 1495 const std::vector<ConstString> &names = 1496 runtime->GetExtendedBacktraceTypes(); 1497 if (idx < names.size()) { 1498 return names[idx].AsCString(); 1499 } else { 1500 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1501 if (log) 1502 log->Printf("SBProcess(%p)::GetExtendedBacktraceTypeAtIndex() => " 1503 "error: requested extended backtrace name out of bounds", 1504 static_cast<void *>(process_sp.get())); 1505 } 1506 } 1507 return NULL; 1508 } 1509 1510 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) { 1511 LLDB_RECORD_METHOD(lldb::SBThreadCollection, SBProcess, GetHistoryThreads, 1512 (lldb::addr_t), addr); 1513 1514 ProcessSP process_sp(GetSP()); 1515 SBThreadCollection threads; 1516 if (process_sp) { 1517 threads = SBThreadCollection(process_sp->GetHistoryThreads(addr)); 1518 } 1519 return LLDB_RECORD_RESULT(threads); 1520 } 1521 1522 bool SBProcess::IsInstrumentationRuntimePresent( 1523 InstrumentationRuntimeType type) { 1524 LLDB_RECORD_METHOD(bool, SBProcess, IsInstrumentationRuntimePresent, 1525 (lldb::InstrumentationRuntimeType), type); 1526 1527 ProcessSP process_sp(GetSP()); 1528 if (!process_sp) 1529 return false; 1530 1531 InstrumentationRuntimeSP runtime_sp = 1532 process_sp->GetInstrumentationRuntime(type); 1533 1534 if (!runtime_sp.get()) 1535 return false; 1536 1537 return runtime_sp->IsActive(); 1538 } 1539 1540 lldb::SBError SBProcess::SaveCore(const char *file_name) { 1541 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, SaveCore, (const char *), 1542 file_name); 1543 1544 lldb::SBError error; 1545 ProcessSP process_sp(GetSP()); 1546 if (!process_sp) { 1547 error.SetErrorString("SBProcess is invalid"); 1548 return LLDB_RECORD_RESULT(error); 1549 } 1550 1551 std::lock_guard<std::recursive_mutex> guard( 1552 process_sp->GetTarget().GetAPIMutex()); 1553 1554 if (process_sp->GetState() != eStateStopped) { 1555 error.SetErrorString("the process is not stopped"); 1556 return LLDB_RECORD_RESULT(error); 1557 } 1558 1559 FileSpec core_file(file_name); 1560 error.ref() = PluginManager::SaveCore(process_sp, core_file); 1561 return LLDB_RECORD_RESULT(error); 1562 } 1563 1564 lldb::SBError 1565 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr, 1566 SBMemoryRegionInfo &sb_region_info) { 1567 LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo, 1568 (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr, 1569 sb_region_info); 1570 1571 lldb::SBError sb_error; 1572 ProcessSP process_sp(GetSP()); 1573 if (process_sp) { 1574 Process::StopLocker stop_locker; 1575 if (stop_locker.TryLock(&process_sp->GetRunLock())) { 1576 std::lock_guard<std::recursive_mutex> guard( 1577 process_sp->GetTarget().GetAPIMutex()); 1578 1579 sb_error.ref() = 1580 process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.ref()); 1581 } else { 1582 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1583 if (log) 1584 log->Printf( 1585 "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", 1586 static_cast<void *>(process_sp.get())); 1587 sb_error.SetErrorString("process is running"); 1588 } 1589 } else { 1590 sb_error.SetErrorString("SBProcess is invalid"); 1591 } 1592 return LLDB_RECORD_RESULT(sb_error); 1593 } 1594 1595 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() { 1596 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBMemoryRegionInfoList, SBProcess, 1597 GetMemoryRegions); 1598 1599 lldb::SBMemoryRegionInfoList sb_region_list; 1600 1601 ProcessSP process_sp(GetSP()); 1602 Process::StopLocker stop_locker; 1603 if (process_sp && stop_locker.TryLock(&process_sp->GetRunLock())) { 1604 std::lock_guard<std::recursive_mutex> guard( 1605 process_sp->GetTarget().GetAPIMutex()); 1606 1607 process_sp->GetMemoryRegions(sb_region_list.ref()); 1608 } else { 1609 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API)); 1610 if (log) 1611 log->Printf( 1612 "SBProcess(%p)::GetMemoryRegionInfo() => error: process is running", 1613 static_cast<void *>(process_sp.get())); 1614 } 1615 1616 return LLDB_RECORD_RESULT(sb_region_list); 1617 } 1618 1619 lldb::SBProcessInfo SBProcess::GetProcessInfo() { 1620 LLDB_RECORD_METHOD_NO_ARGS(lldb::SBProcessInfo, SBProcess, GetProcessInfo); 1621 1622 lldb::SBProcessInfo sb_proc_info; 1623 ProcessSP process_sp(GetSP()); 1624 ProcessInstanceInfo proc_info; 1625 if (process_sp && process_sp->GetProcessInfo(proc_info)) { 1626 sb_proc_info.SetProcessInfo(proc_info); 1627 } 1628 return LLDB_RECORD_RESULT(sb_proc_info); 1629 } 1630