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