1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "native_memory_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint32_t itid,uint64_t timeStamp)19 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId,
20 uint32_t ipid,
21 uint32_t itid,
22 uint64_t timeStamp)
23 {
24 ids_.emplace_back(id_++);
25 callChainIds_.emplace_back(callChainId);
26 ipids_.emplace_back(ipid);
27 internalTids_.emplace_back(itid);
28 timeStamps_.emplace_back(timeStamp);
29 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
30 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
31 }
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint64_t timeStamp)32 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId, uint32_t ipid, uint64_t timeStamp)
33 {
34 ids_.emplace_back(id_++);
35 callChainIds_.emplace_back(callChainId);
36 ipids_.emplace_back(ipid);
37 timeStamps_.emplace_back(timeStamp);
38 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
39 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
40 }
CallChainIds() const41 const std::deque<uint32_t> &NativeHookSampleBase::CallChainIds() const
42 {
43 return callChainIds_;
44 }
Ipids() const45 const std::deque<uint32_t> &NativeHookSampleBase::Ipids() const
46 {
47 return ipids_;
48 }
LastCallerPathIndexs() const49 const std::deque<uint64_t> &NativeHookSampleBase::LastCallerPathIndexs() const
50 {
51 return lastCallerPathIndexs_;
52 }
LastSymbolIndexs() const53 const std::deque<uint64_t> &NativeHookSampleBase::LastSymbolIndexs() const
54 {
55 return lastSymbolIndexs_;
56 }
UpdateLastCallerPathAndSymbolIndexs(std::unordered_map<uint32_t,std::tuple<DataIndex,DataIndex>> & callIdToLasLibId)57 void NativeHookSampleBase::UpdateLastCallerPathAndSymbolIndexs(
58 std::unordered_map<uint32_t, std::tuple<DataIndex, DataIndex>> &callIdToLasLibId)
59 {
60 if (callIdToLasLibId.empty()) {
61 return;
62 }
63 for (auto i = 0; i < Size(); ++i) {
64 auto symbolIt = callIdToLasLibId.find(callChainIds_[i]);
65 if (symbolIt != callIdToLasLibId.end()) {
66 std::tie(lastCallerPathIndexs_[i], lastSymbolIndexs_[i]) = symbolIt->second;
67 } else {
68 lastCallerPathIndexs_[i] = INVALID_DATAINDEX;
69 lastSymbolIndexs_[i] = INVALID_DATAINDEX;
70 }
71 }
72 }
AppendNewNativeHookData(const NativeHookRow & context)73 size_t NativeHook::AppendNewNativeHookData(const NativeHookRow &context)
74 {
75 AppendNativeHookSampleBase(context.callChainId, context.ipid, context.itid, context.timeStamp);
76 eventTypes_.emplace_back(context.eventType);
77 subTypes_.emplace_back(context.subType);
78 endTimeStamps_.emplace_back(context.endTimeStamp);
79 durations_.emplace_back(context.duration);
80 addrs_.emplace_back(context.addr);
81 memSizes_.emplace_back(context.memSize);
82 if (context.eventType == ALLOC_EVET) {
83 countHeapSizes_ += context.memSize;
84 allMemSizes_.emplace_back(countHeapSizes_);
85 } else if (context.eventType == FREE_EVENT) {
86 countHeapSizes_ -= context.memSize;
87 allMemSizes_.emplace_back(countHeapSizes_);
88 } else if (context.eventType == MMAP_EVENT) {
89 countMmapSizes_ += context.memSize;
90 allMemSizes_.emplace_back(countMmapSizes_);
91 } else if (context.eventType == MUNMAP_EVENT) {
92 countMmapSizes_ -= context.memSize;
93 allMemSizes_.emplace_back(countMmapSizes_);
94 }
95 currentSizeDurs_.emplace_back(0);
96 return Size() - 1;
97 }
UpdateCallChainId(size_t row,uint32_t callChainId)98 void NativeHook::UpdateCallChainId(size_t row, uint32_t callChainId)
99 {
100 if (row < Size()) {
101 callChainIds_[row] = callChainId;
102 } else {
103 TS_LOGE("Native hook update callChainId failed!!!");
104 }
105 }
UpdateEndTimeStampAndDuration(size_t row,uint64_t endTimeStamp)106 void NativeHook::UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp)
107 {
108 endTimeStamps_[row] = endTimeStamp;
109 durations_[row] = endTimeStamp - timeStamps_[row];
110 }
UpdateCurrentSizeDur(size_t row,uint64_t timeStamp)111 void NativeHook::UpdateCurrentSizeDur(size_t row, uint64_t timeStamp)
112 {
113 currentSizeDurs_[row] = timeStamp - timeStamps_[row];
114 }
UpdateMemMapSubType(uint64_t row,uint64_t tagId)115 void NativeHook::UpdateMemMapSubType(uint64_t row, uint64_t tagId)
116 {
117 if (row < subTypes_.size()) {
118 subTypes_[row] = tagId;
119 } else {
120 TS_LOGE("subTypes_ row is invalid!");
121 }
122 }
EventTypes() const123 const std::deque<std::string> &NativeHook::EventTypes() const
124 {
125 return eventTypes_;
126 }
SubTypes() const127 const std::deque<DataIndex> &NativeHook::SubTypes() const
128 {
129 return subTypes_;
130 }
EndTimeStamps() const131 const std::deque<uint64_t> &NativeHook::EndTimeStamps() const
132 {
133 return endTimeStamps_;
134 }
Durations() const135 const std::deque<uint64_t> &NativeHook::Durations() const
136 {
137 return durations_;
138 }
Addrs() const139 const std::deque<uint64_t> &NativeHook::Addrs() const
140 {
141 return addrs_;
142 }
MemSizes() const143 const std::deque<int64_t> &NativeHook::MemSizes() const
144 {
145 return memSizes_;
146 }
AllMemSizes() const147 const std::deque<int64_t> &NativeHook::AllMemSizes() const
148 {
149 return allMemSizes_;
150 }
CurrentSizeDurs() const151 const std::deque<uint64_t> &NativeHook::CurrentSizeDurs() const
152 {
153 return currentSizeDurs_;
154 }
AppendNewNativeHookFrame(const NativeHookFrameVaddrRow & context)155 size_t NativeHookFrame::AppendNewNativeHookFrame(const NativeHookFrameVaddrRow &context)
156 {
157 callChainIds_.emplace_back(context.callChainId);
158 ips_.emplace_back(context.ip);
159 depths_.emplace_back(context.depth);
160 symbolNames_.emplace_back(context.symbolName);
161 filePaths_.emplace_back(context.filePath);
162 offsets_.emplace_back(context.offset);
163 symbolOffsets_.emplace_back(context.symbolOffset);
164 vaddrs_.emplace_back(context.vaddr);
165 return Size() - 1;
166 }
AppendNewNativeHookFrame(const NativeHookFrameRow & context)167 size_t NativeHookFrame::AppendNewNativeHookFrame(const NativeHookFrameRow &context)
168 {
169 callChainIds_.emplace_back(context.callChainId);
170 ips_.emplace_back(context.ip);
171 depths_.emplace_back(context.depth);
172 symbolNames_.emplace_back(context.symbolName);
173 filePaths_.emplace_back(context.filePath);
174 offsets_.emplace_back(context.offset);
175 symbolOffsets_.emplace_back(context.symbolOffset);
176 return Size() - 1;
177 }
UpdateSymbolIdToNameMap(uint64_t originSymbolId,uint64_t symbolId)178 void NativeHookFrame::UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId)
179 {
180 symbolIdToSymbolName_.insert(std::make_pair(originSymbolId, symbolId));
181 }
UpdateFrameInfo(size_t row,DataIndex symbolIndex,DataIndex filePathIndex,uint64_t offset,uint64_t symbolOffset)182 void NativeHookFrame::UpdateFrameInfo(size_t row,
183 DataIndex symbolIndex,
184 DataIndex filePathIndex,
185 uint64_t offset,
186 uint64_t symbolOffset)
187 {
188 if (row >= Size()) {
189 TS_LOGE("The updated row does not exist!");
190 return;
191 }
192 symbolNames_[row] = symbolIndex;
193 filePaths_[row] = filePathIndex;
194 offsets_[row] = offset;
195 symbolOffsets_[row] = symbolOffset;
196 }
197
UpdateSymbolId()198 void NativeHookFrame::UpdateSymbolId()
199 {
200 if (symbolIdToSymbolName_.empty()) {
201 return;
202 }
203 for (auto i = 0; i < Size(); ++i) {
204 auto symbolIt = symbolIdToSymbolName_.find(symbolNames_[i]);
205 if (symbolIt != symbolIdToSymbolName_.end()) {
206 symbolNames_[i] = symbolIt->second;
207 }
208 }
209 }
UpdateSymbolId(size_t index,DataIndex symbolId)210 void NativeHookFrame::UpdateSymbolId(size_t index, DataIndex symbolId)
211 {
212 if (index < Size()) {
213 symbolNames_[index] = symbolId;
214 }
215 }
UpdateFileId(std::map<uint32_t,uint64_t> & filePathIdToFilePathName)216 void NativeHookFrame::UpdateFileId(std::map<uint32_t, uint64_t> &filePathIdToFilePathName)
217 {
218 if (filePathIdToFilePathName.empty()) {
219 return;
220 }
221 for (auto i = 0; i < Size(); ++i) {
222 auto symbolIt = filePathIdToFilePathName.find(filePaths_[i]);
223 if (symbolIt != filePathIdToFilePathName.end()) {
224 filePaths_[i] = symbolIt->second;
225 }
226 }
227 }
UpdateVaddrs(std::deque<std::string> & vaddrs)228 void NativeHookFrame::UpdateVaddrs(std::deque<std::string> &vaddrs)
229 {
230 vaddrs_.assign(vaddrs.begin(), vaddrs.end());
231 }
ClearUselessCallChainIds(const std::unordered_set<uint32_t> & callChainIdsSet)232 void NativeHookFrame::ClearUselessCallChainIds(const std::unordered_set<uint32_t> &callChainIdsSet)
233 {
234 std::deque<uint32_t> callChainIdsTmp;
235 std::deque<uint16_t> depthsTmp;
236 std::deque<uint64_t> ipsTmp;
237 std::deque<DataIndex> symbolNamesTmp;
238 std::deque<DataIndex> filePathsTmp;
239 std::deque<uint64_t> offsetsTmp;
240 std::deque<uint64_t> symbolOffsetsTmp;
241 std::deque<std::string> vaddrsTmp;
242 for (size_t i = 0; i < callChainIds_.size(); i++) {
243 if (callChainIdsSet.find(callChainIds_[i]) == callChainIdsSet.end()) {
244 continue;
245 }
246 callChainIdsTmp.emplace_back(callChainIds_[i]);
247 depthsTmp.emplace_back(depths_[i]);
248 ipsTmp.emplace_back(ips_[i]);
249 symbolNamesTmp.emplace_back(symbolNames_[i]);
250 filePathsTmp.emplace_back(filePaths_[i]);
251 offsetsTmp.emplace_back(offsets_[i]);
252 symbolOffsetsTmp.emplace_back(symbolOffsets_[i]);
253 vaddrsTmp.emplace_back(vaddrs_[i]);
254 }
255 callChainIds_.swap(callChainIdsTmp);
256 depths_.swap(depthsTmp);
257 ips_.swap(ipsTmp);
258 symbolNames_.swap(symbolNamesTmp);
259 filePaths_.swap(filePathsTmp);
260 offsets_.swap(offsetsTmp);
261 symbolOffsets_.swap(symbolOffsetsTmp);
262 vaddrs_.swap(vaddrsTmp);
263 }
CallChainIds() const264 const std::deque<uint32_t> &NativeHookFrame::CallChainIds() const
265 {
266 return callChainIds_;
267 }
Depths() const268 const std::deque<uint16_t> &NativeHookFrame::Depths() const
269 {
270 return depths_;
271 }
Ips() const272 const std::deque<uint64_t> &NativeHookFrame::Ips() const
273 {
274 return ips_;
275 }
SymbolNames() const276 const std::deque<DataIndex> &NativeHookFrame::SymbolNames() const
277 {
278 return symbolNames_;
279 }
FilePaths() const280 const std::deque<DataIndex> &NativeHookFrame::FilePaths() const
281 {
282 return filePaths_;
283 }
Offsets() const284 const std::deque<uint64_t> &NativeHookFrame::Offsets() const
285 {
286 return offsets_;
287 }
SymbolOffsets() const288 const std::deque<uint64_t> &NativeHookFrame::SymbolOffsets() const
289 {
290 return symbolOffsets_;
291 }
Vaddrs() const292 const std::deque<std::string> &NativeHookFrame::Vaddrs() const
293 {
294 return vaddrs_;
295 }
296
AppendNewNativeHookStatistic(const NativeHookStatisticRow & nativeHookStatisticRow)297 size_t NativeHookStatistic::AppendNewNativeHookStatistic(const NativeHookStatisticRow &nativeHookStatisticRow)
298 {
299 AppendNativeHookSampleBase(nativeHookStatisticRow.callChainId, nativeHookStatisticRow.ipid,
300 nativeHookStatisticRow.timeStamp);
301 memoryTypes_.emplace_back(nativeHookStatisticRow.memoryType);
302 applyCounts_.emplace_back(nativeHookStatisticRow.applyCount);
303 memSubTypes_.emplace_back(nativeHookStatisticRow.subMemType);
304 releaseCounts_.emplace_back(nativeHookStatisticRow.releaseCount);
305 applySizes_.emplace_back(nativeHookStatisticRow.applySize);
306 releaseSizes_.emplace_back(nativeHookStatisticRow.releaseSize);
307 return Size() - 1;
308 }
309
MemoryTypes() const310 const std::deque<uint32_t> &NativeHookStatistic::MemoryTypes() const
311 {
312 return memoryTypes_;
313 }
MemorySubTypes() const314 const std::deque<DataIndex> &NativeHookStatistic::MemorySubTypes() const
315 {
316 return memSubTypes_;
317 }
ApplyCounts() const318 const std::deque<uint64_t> &NativeHookStatistic::ApplyCounts() const
319 {
320 return applyCounts_;
321 }
ReleaseCounts() const322 const std::deque<uint64_t> &NativeHookStatistic::ReleaseCounts() const
323 {
324 return releaseCounts_;
325 }
ApplySizes() const326 const std::deque<uint64_t> &NativeHookStatistic::ApplySizes() const
327 {
328 return applySizes_;
329 }
ReleaseSizes() const330 const std::deque<uint64_t> &NativeHookStatistic::ReleaseSizes() const
331 {
332 return releaseSizes_;
333 }
334 } // namespace TraceStdtype
335 } // namespace SysTuning
336