1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
| //===-- SBAttachInfo.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_SBAttachInfo_h_
#define LLDB_SBAttachInfo_h_
#include "lldb/API/SBDefines.h"
namespace lldb {
class SBTarget;
class LLDB_API SBAttachInfo {
public:
SBAttachInfo();
SBAttachInfo(lldb::pid_t pid);
/// Attach to a process by name.
///
/// This function implies that a future call to SBTarget::Attach(...)
/// will be synchronous.
///
/// \param[in] path
/// A full or partial name for the process to attach to.
///
/// \param[in] wait_for
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
SBAttachInfo(const char *path, bool wait_for);
/// Attach to a process by name.
///
/// Future calls to SBTarget::Attach(...) will be synchronous or
/// asynchronous depending on the \a async argument.
///
/// \param[in] path
/// A full or partial name for the process to attach to.
///
/// \param[in] wait_for
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
///
/// \param[in] async
/// If \b false, then the SBTarget::Attach(...) call will be a
/// synchronous call with no way to cancel the attach in
/// progress.
/// If \b true, then the SBTarget::Attach(...) function will
/// return immediately and clients are expected to wait for a
/// process eStateStopped event if a suitable process is
/// eventually found. If the client wants to cancel the event,
/// SBProcess::Stop() can be called and an eStateExited process
/// event will be delivered.
SBAttachInfo(const char *path, bool wait_for, bool async);
SBAttachInfo(const SBAttachInfo &rhs);
~SBAttachInfo();
SBAttachInfo &operator=(const SBAttachInfo &rhs);
lldb::pid_t GetProcessID();
void SetProcessID(lldb::pid_t pid);
void SetExecutable(const char *path);
void SetExecutable(lldb::SBFileSpec exe_file);
bool GetWaitForLaunch();
/// Set attach by process name settings.
///
/// Designed to be used after a call to SBAttachInfo::SetExecutable().
/// This function implies that a call to SBTarget::Attach(...) will
/// be synchronous.
///
/// \param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
void SetWaitForLaunch(bool b);
/// Set attach by process name settings.
///
/// Designed to be used after a call to SBAttachInfo::SetExecutable().
/// Future calls to SBTarget::Attach(...) will be synchronous or
/// asynchronous depending on the \a async argument.
///
/// \param[in] b
/// If \b false, attach to an existing process whose name matches.
/// If \b true, then wait for the next process whose name matches.
///
/// \param[in] async
/// If \b false, then the SBTarget::Attach(...) call will be a
/// synchronous call with no way to cancel the attach in
/// progress.
/// If \b true, then the SBTarget::Attach(...) function will
/// return immediately and clients are expected to wait for a
/// process eStateStopped event if a suitable process is
/// eventually found. If the client wants to cancel the event,
/// SBProcess::Stop() can be called and an eStateExited process
/// event will be delivered.
void SetWaitForLaunch(bool b, bool async);
bool GetIgnoreExisting();
void SetIgnoreExisting(bool b);
uint32_t GetResumeCount();
void SetResumeCount(uint32_t c);
const char *GetProcessPluginName();
void SetProcessPluginName(const char *plugin_name);
uint32_t GetUserID();
uint32_t GetGroupID();
bool UserIDIsValid();
bool GroupIDIsValid();
void SetUserID(uint32_t uid);
void SetGroupID(uint32_t gid);
uint32_t GetEffectiveUserID();
uint32_t GetEffectiveGroupID();
bool EffectiveUserIDIsValid();
bool EffectiveGroupIDIsValid();
void SetEffectiveUserID(uint32_t uid);
void SetEffectiveGroupID(uint32_t gid);
lldb::pid_t GetParentProcessID();
void SetParentProcessID(lldb::pid_t pid);
bool ParentProcessIDIsValid();
/// Get the listener that will be used to receive process events.
///
/// If no listener has been set via a call to
/// SBAttachInfo::SetListener(), then an invalid SBListener will be
/// returned (SBListener::IsValid() will return false). If a listener
/// has been set, then the valid listener object will be returned.
SBListener GetListener();
/// Set the listener that will be used to receive process events.
///
/// By default the SBDebugger, which has a listener, that the SBTarget
/// belongs to will listen for the process events. Calling this function
/// allows a different listener to be used to listen for process events.
void SetListener(SBListener &listener);
protected:
friend class SBTarget;
lldb_private::ProcessAttachInfo &ref();
ProcessAttachInfoSP m_opaque_sp;
};
} // namespace lldb
#endif // LLDB_SBAttachInfo_h_
|