1 //===-- SBProcessInfo.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/SBProcessInfo.h"
10 #include "SBReproducerPrivate.h"
11 #include "Utils.h"
12 #include "lldb/API/SBFileSpec.h"
13 #include "lldb/Utility/ProcessInfo.h"
14 
15 using namespace lldb;
16 using namespace lldb_private;
17 
18 SBProcessInfo::SBProcessInfo() : m_opaque_up() {
19   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBProcessInfo);
20 }
21 
22 SBProcessInfo::SBProcessInfo(const SBProcessInfo &rhs) : m_opaque_up() {
23   LLDB_RECORD_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &), rhs);
24 
25   m_opaque_up = clone(rhs.m_opaque_up);
26 }
27 
28 SBProcessInfo::~SBProcessInfo() = default;
29 
30 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
31   LLDB_RECORD_METHOD(lldb::SBProcessInfo &,
32                      SBProcessInfo, operator=,(const lldb::SBProcessInfo &),
33                      rhs);
34 
35   if (this != &rhs)
36     m_opaque_up = clone(rhs.m_opaque_up);
37   return LLDB_RECORD_RESULT(*this);
38 }
39 
40 ProcessInstanceInfo &SBProcessInfo::ref() {
41   if (m_opaque_up == nullptr) {
42     m_opaque_up = std::make_unique<ProcessInstanceInfo>();
43   }
44   return *m_opaque_up;
45 }
46 
47 void SBProcessInfo::SetProcessInfo(const ProcessInstanceInfo &proc_info_ref) {
48   ref() = proc_info_ref;
49 }
50 
51 bool SBProcessInfo::IsValid() const {
52   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, IsValid);
53   return this->operator bool();
54 }
55 SBProcessInfo::operator bool() const {
56   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBProcessInfo, operator bool);
57 
58   return m_opaque_up != nullptr;
59 }
60 
61 const char *SBProcessInfo::GetName() {
62   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBProcessInfo, GetName);
63 
64   const char *name = nullptr;
65   if (m_opaque_up) {
66     name = m_opaque_up->GetName();
67   }
68   return name;
69 }
70 
71 SBFileSpec SBProcessInfo::GetExecutableFile() {
72   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFileSpec, SBProcessInfo,
73                              GetExecutableFile);
74 
75   SBFileSpec file_spec;
76   if (m_opaque_up) {
77     file_spec.SetFileSpec(m_opaque_up->GetExecutableFile());
78   }
79   return LLDB_RECORD_RESULT(file_spec);
80 }
81 
82 lldb::pid_t SBProcessInfo::GetProcessID() {
83   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetProcessID);
84 
85   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
86   if (m_opaque_up) {
87     proc_id = m_opaque_up->GetProcessID();
88   }
89   return proc_id;
90 }
91 
92 uint32_t SBProcessInfo::GetUserID() {
93   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetUserID);
94 
95   uint32_t user_id = UINT32_MAX;
96   if (m_opaque_up) {
97     user_id = m_opaque_up->GetUserID();
98   }
99   return user_id;
100 }
101 
102 uint32_t SBProcessInfo::GetGroupID() {
103   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetGroupID);
104 
105   uint32_t group_id = UINT32_MAX;
106   if (m_opaque_up) {
107     group_id = m_opaque_up->GetGroupID();
108   }
109   return group_id;
110 }
111 
112 bool SBProcessInfo::UserIDIsValid() {
113   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, UserIDIsValid);
114 
115   bool is_valid = false;
116   if (m_opaque_up) {
117     is_valid = m_opaque_up->UserIDIsValid();
118   }
119   return is_valid;
120 }
121 
122 bool SBProcessInfo::GroupIDIsValid() {
123   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, GroupIDIsValid);
124 
125   bool is_valid = false;
126   if (m_opaque_up) {
127     is_valid = m_opaque_up->GroupIDIsValid();
128   }
129   return is_valid;
130 }
131 
132 uint32_t SBProcessInfo::GetEffectiveUserID() {
133   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveUserID);
134 
135   uint32_t user_id = UINT32_MAX;
136   if (m_opaque_up) {
137     user_id = m_opaque_up->GetEffectiveUserID();
138   }
139   return user_id;
140 }
141 
142 uint32_t SBProcessInfo::GetEffectiveGroupID() {
143   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBProcessInfo, GetEffectiveGroupID);
144 
145   uint32_t group_id = UINT32_MAX;
146   if (m_opaque_up) {
147     group_id = m_opaque_up->GetEffectiveGroupID();
148   }
149   return group_id;
150 }
151 
152 bool SBProcessInfo::EffectiveUserIDIsValid() {
153   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveUserIDIsValid);
154 
155   bool is_valid = false;
156   if (m_opaque_up) {
157     is_valid = m_opaque_up->EffectiveUserIDIsValid();
158   }
159   return is_valid;
160 }
161 
162 bool SBProcessInfo::EffectiveGroupIDIsValid() {
163   LLDB_RECORD_METHOD_NO_ARGS(bool, SBProcessInfo, EffectiveGroupIDIsValid);
164 
165   bool is_valid = false;
166   if (m_opaque_up) {
167     is_valid = m_opaque_up->EffectiveGroupIDIsValid();
168   }
169   return is_valid;
170 }
171 
172 lldb::pid_t SBProcessInfo::GetParentProcessID() {
173   LLDB_RECORD_METHOD_NO_ARGS(lldb::pid_t, SBProcessInfo, GetParentProcessID);
174 
175   lldb::pid_t proc_id = LLDB_INVALID_PROCESS_ID;
176   if (m_opaque_up) {
177     proc_id = m_opaque_up->GetParentProcessID();
178   }
179   return proc_id;
180 }
181 
182 namespace lldb_private {
183 namespace repro {
184 
185 template <>
186 void RegisterMethods<SBProcessInfo>(Registry &R) {
187   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, ());
188   LLDB_REGISTER_CONSTRUCTOR(SBProcessInfo, (const lldb::SBProcessInfo &));
189   LLDB_REGISTER_METHOD(
190       lldb::SBProcessInfo &,
191       SBProcessInfo, operator=,(const lldb::SBProcessInfo &));
192   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, IsValid, ());
193   LLDB_REGISTER_METHOD_CONST(bool, SBProcessInfo, operator bool, ());
194   LLDB_REGISTER_METHOD(const char *, SBProcessInfo, GetName, ());
195   LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBProcessInfo, GetExecutableFile,
196                        ());
197   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetProcessID, ());
198   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetUserID, ());
199   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetGroupID, ());
200   LLDB_REGISTER_METHOD(bool, SBProcessInfo, UserIDIsValid, ());
201   LLDB_REGISTER_METHOD(bool, SBProcessInfo, GroupIDIsValid, ());
202   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveUserID, ());
203   LLDB_REGISTER_METHOD(uint32_t, SBProcessInfo, GetEffectiveGroupID, ());
204   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveUserIDIsValid, ());
205   LLDB_REGISTER_METHOD(bool, SBProcessInfo, EffectiveGroupIDIsValid, ());
206   LLDB_REGISTER_METHOD(lldb::pid_t, SBProcessInfo, GetParentProcessID, ());
207 }
208 
209 }
210 }
211